DEV Community: Aasif Ashraf

My 14-Year-Old Self Built a Pen-and-Paper Cipher (And Locked Me Out 14 Years Later)

Aasif Ashraf — Thu, 16 Jul 2026 07:13:43 +0000

Orignal Post : aasifashraf.dev/blogs

As developers, we spend a lot of time thinking about encryption, secure authentication, and algorithmic logic. But recently I stumbled across a piece of paper from 2012 that reminded me I have been overengineering security systems since I was 14 years old.

I found an old handwritten note labeled “My E-mail Password.” It wasn’t a password. It was a full-blown cryptographic escape room. Back then, living in Jammu & Kashmir when the internet had barely arrived and most calls still went through a landline, a personal email felt like owning a small piece of the future. I was terrified of forgetting the password, but writing it in plain text felt wrong, so I built this instead. It was so complex that today, 14 years later, I could not fully decode it myself.

Press enter or click to view image in full size

Here is a breakdown of the analog encryption algorithm my teenage brain invented. What makes it interesting is that none of it is throwaway: every string, number, and grid cell is live data, and the password only appears once you make all the layers interact.

The Mathematical Key At the bottom-right of the page sat a math problem: kx(x-2)+6=0. To even begin, you had to solve this quadratic for the case where the roots are equal, which gives k=6. That number 6 was the master pointer for the rest of the sheet, selecting which line the assembly would anchor on.

Become a Medium member
math

kx(x-2) + 6 = 0
=> k·x^2 - 2k·x + 6 = 0

equal roots => discriminant = 0
(2k)^2 - 4·k·6 = 0
4k^2 - 24k = 0
4k(k - 6) = 0
=> k = 6 (the master pointer)

Eight Working Fragments
The top-left held eight complex, scrambled password-like strings. The trap: if someone solved the key and guessed the 6th string was the password, they would fail. The real password was never written on any single line. It was fractured into pieces, a word, a date-like number run, and symbols, and those pieces were distributed across all eight strings at once. Every line carried a real part; none of them was a throwaway decoy.
The Relational Cipher Matrix
This is where it got out of hand. The right side of the page added three interacting parts under the instruction “Nm thn elp” (Number, then elp):

A list of nine long numeric strings: a key stream that dictated reading order.
A 5x5 substitution matrix of letter pairs, labeled ‘elp’.
A set of (x, y) coordinates, plus an assembly sequence that fixed the final order.
To reassemble the password you cross-referenced the key stream against the coordinates, ran the result through the 5x5 matrix, and pulled characters out of the eight strings in exactly the right order. Get one step wrong and you got noise. Get every step right and the password fell out.

This is precisely why engineers do not roll their own crypto. A homemade scheme feels unbreakable because you hold the trick in your head. The moment that memory fades, it is unbreakable even to you, which is the opposite of what a security system is for.

The Verdict
I might not remember the exact final execution step today, but I remember it worked perfectly back then. It kept everyone out, and it let me in. Looking at this sheet is a humbling reminder of where my developer journey actually started: before I could write code, I was already writing analog algorithms.

I have always loved building complex systems, even when that meant making it absurdly hard just to check my own email. The instinct to protect information came years before the knowledge of how to do it properly, and closing that gap is a good description of what learning to be an engineer really is.

I Built My Developer Portfolio Using Next.js

Aasif Ashraf — Wed, 08 Apr 2026 15:46:41 +0000

I Built My Developer Portfolio Using Next.js (100 Lighthouse Score)

I recently built and deployed my personal portfolio using Next.js, focusing on performance, clean UI, and best practices. One of my main goals was to create a fast and accessible experience — and I managed to achieve a perfect 100 score across all Lighthouse metrics.

In this project, I focused on:

Optimized performance and SEO
Clean and minimal UI/UX
Scalable and production-ready structure

I’d really appreciate any feedback from the community — especially on design, structure, or anything I can improve.

https://aasifashraf.dev/

I Built My Developer Portfolio Using Next.js (100 Lighthouse Score) I recently built and deployed my personal portfolio using Next.js, focusing on performance, clean UI, and best practices. One of my main goals was to create a fast and accessible exper

Aasif Ashraf — Tue, 07 Apr 2026 15:19:55 +0000

I Built a Production-Ready Express.js Backend Scaffolder and It Reached 1,500 Downloads in 2 Days

Aasif Ashraf — Mon, 02 Mar 2026 06:02:45 +0000

Starting a new Node.js and Express project should feel exciting.

For me, it usually started the same way rewriting the exact same setup every time:

Configure Express
Set up CORS
Add dotenv
Write global error handling
Organize folders
Standardize API responses
Configure middleware

None of this work is difficult. It’s just repetitive.

After doing this across multiple projects, I realized I was spending more time rebuilding structure than actually solving problems. So I decided to automate it.

The Idea

I built create-express-kickstart, a CLI tool that scaffolds a production-ready Express backend with sensible defaults and a clean structure.

The goal wasn’t to replace Express or introduce another framework.

It was simple:

Start from a solid baseline and focus on building features instead of rewriting boilerplate.

Quick Start

npx create-express-kickstart@latest my-app

Within seconds, you get a structured backend ready to build on.

What It Sets Up

Out of the box, the project includes:

Clean and scalable folder structure
Centralized error handling
Middleware configuration
Environment setup using .env
CORS configuration
Standardized API response patterns
Organized routing structure

It’s essentially the setup I found myself recreating manually for every project.

Why I Built It

Many tutorials focus on getting Express running quickly, which is great for learning.

But real projects usually need more structure almost immediately.

I wanted a starting point that:

Feels close to something you could actually deploy
Encourages consistency across projects
Remains simple without unnecessary abstraction

Basically, a backend I wouldn’t dread inheriting six months later.

The Early Response

After publishing it to npm, the package crossed around 1,500 downloads in two days.

I understand npm downloads aren’t perfect metrics. They can include CI installs and automated pulls.

Still, seeing people try it, discuss it, and give feedback was encouraging — especially as a first public package.

What I Learned

Publishing something publicly feels very different from building it privately.

A few takeaways:

1. Practical tools resonate

Developers appreciate solutions that remove repetitive work.

2. Feedback comes quickly

Some people were supportive. Some were skeptical. That’s part of open source.

3. Shipping matters more than perfection

I considered waiting until it felt more complete. I’m glad I didn’t.

What’s Next

I’m continuing to improve it based on feedback.

Some things I’m exploring:

Optional database integrations
Authentication starter modules
Better CLI customization
Optional testing setup

If you have suggestions or think something important is missing, I’d genuinely like to hear them.

Project Links

GitHub Repository:

https://github.com/aasifashraf/create-express-kickstart

npm Package:

https://www.npmjs.com/package/create-express-kickstart

Thanks for reading.