How It All Started

My father, Nitin Basena, bought my first computer. A basic desktop. Nothing fancy. But to me, it was the most fascinating thing in the world.

Alongside it sat dad's old laptop — born the same year as me. That machine became my second playground. Between the two, I had enough hardware to break, fix, and learn from.

Within weeks, it started having problems. Technical faults, random crashes, glitches that nobody in my family could figure out. But something strange happened — I started fixing them. Not because I understood what I was doing, but because I was curious enough to try.

Every time something broke, a spark got inside me. I'd open the case, look at the components, and somehow make it work again. That was the moment I first acquired my hardware hacking skill — though I didn't know it had a name yet.

I fell in love with gaming. Not just playing — understanding how games worked. I wanted to create my own. That's when I discovered Unreal Engine and tried to build a game.

The problem? Games need code. So I learned my first programming language — C. I was 4 years old. While other kids were learning ABC, I was learning pointers, memory allocation, and loops.

It wasn't easy. The concepts were abstract, the syntax was confusing, and nobody around me could help. But I kept at it. Line by line, function by function, the journey of learning programming languages had officially begun.

After C, I discovered Python. The simplicity of it — no semicolons, no curly braces, just clean readable code — fascinated me. I picked it up in weeks.

Then came HTML, CSS, and JavaScript. I built my first website at age 5. It was terrible — a basic page with a red background and comic sans font. But it was mine. I made something from nothing, and that feeling was addictive.

By age 7, I was already exploring beyond the surface. I wanted to understand how the web really worked — not just the browser, but the servers, the protocols, the infrastructure underneath.

Something clicked. I realized that every programming language was like a key — each one unlocking a different kind of problem. So I started collecting them.

Go for systems. Rust for performance. Java for enterprise. C++ for games. Ruby for scripting. Assembly for understanding how computers really work. Swift, Kotlin, Dart, Lua, Haskell, Scala — one after another, the list grew.

People asked why. "You don't need 70 languages," they said. But I wasn't learning them to use them all. I was learning them to understand the patterns, the philosophies, the different ways humans think about problems.

By age 10, I had learned 70+ programming languages. Not memorized syntax — understood paradigms. Object-oriented, functional, procedural, declarative, assembly-level. Each one a new lens to see the world.

At age 7, I installed my first Linux distro — Parrot OS. Something about having a terminal, being able to control every process, root access to my own machine — it felt like real power. Parrot was my gateway into the world of security-focused Linux.

Then came the distro-hopping phase. Gentoo — where I learned to compile everything from source and understood what "building your own system" really meant. Pentoo — Gentoo's security sibling, perfect for my growing interest in pen testing. Ubuntu — the "easy" one, but I didn't like it. Too much hand-holding. Kali — everyone's favorite hacker OS, but I quickly realized real hackers don't need a pre-built toolkit. Garuda Linux Dragonized — the beautiful one, with its KDE Plasma setup that made me realize Linux could look stunning.

But I didn't stop at 6 distros. I kept going. Arch, Debian, Fedora, openSUSE, Manjaro, EndeavourOS, Pop!_OS, Linux Mint, Zorin OS, NixOS, Void Linux, Alpine, Rocky Linux, AlmaLinux, Slackware, Crux, Artix, ArcoLinux, RebornOS, CachyOS, DraugerOS, Regolith, i3wm setups, BSPWM rice, custom window managers — the list kept growing. By now I've used 50+ Linux distros. Each one taught me something different. Arch taught me to read the manual. Gentoo taught me compilation. Alpine taught me minimalism. Void taught me runit. NixOS taught me declarative systems. Every distro was a lesson in how different people solve the same problems differently.

Then at age 12, I went deeper. Way deeper. I explored the dark web. Not the "let me buy something illegal" dark web — the technical side. I wanted to understand how Tor worked, how onion routing functioned, what hidden services really were. I set up Tor bridges, configured relay nodes, explored .onion sites. I found Marinas web — a lesser-known network layer that sits between the surface web and the deep web, used by specific research communities. I explored Primarch web — an even more obscure protocol layer used by academic and military-grade research networks. I didn't use them for anything illegal. I studied them. I reverse-engineered the protocols, mapped the network topologies, documented everything. By 13, I had a deeper understanding of internet infrastructure than most adults working in tech.

Every distro, every network, every hidden layer — they all fed into the same obsession: understanding how things work underneath. Not the surface. The plumbing. The wires. The protocols nobody sees.

In 2022, my father got transferred from Amravati to Nagpur. Everything changed — city, school, environment. I went from St Xavier's Cathedral School, Amravati (where I studied from 2014 to 2022) to St Vincent Pallotti School, Besa, Nagpur.

New city meant new opportunities. In 2023, I joined Webnet Institute in Manewada. That's where I formally learned React and intermediate web development — hooks, component architecture, state management. I was in 8th grade.

That same year, a new robotics lab was introduced at school with a new teacher — Shrikant Thakre. Sir didn't just teach us robotics in class. During every long break, I went back to the lab to create projects and learn more. Arduino, IoT, sensors, microcontrollers, motor drivers, wireless communication — he pushed me from 87% to 95% on almost everything. He taught me how to think with my hands, not just my head.

The transition wasn't easy. Leaving friends, adapting to a new school, new teachers, new curriculum. But code was the constant. No matter what changed around me, the terminal was always the same.

Security found me. Or maybe I found it. Either way, once I started looking at systems through the lens of vulnerabilities, I couldn't stop.

I dove into penetration testing — finding flaws in web applications, networks, and systems. Not to break them, but to understand them. Every vulnerability was a lesson in how things can go wrong.

I built tools: ShadowSentinel (an ML-powered network intrusion detection system), VulnScope (a vulnerability intelligence platform), AI Pentest Agent (autonomous penetration testing). Each one teaching me something new about attack vectors, defense mechanisms, and system resilience.

Then at age 12, I went deeper. I explored the dark web. Not for illegal activities — I studied the technology. I set up Tor bridges, configured relay nodes, explored .onion hidden services, and reverse-engineered how onion routing works. I found Marinas web — a lesser-known network layer between the surface and deep web, used by research communities. And I explored Primarch web — an even more obscure protocol layer used by academic and military-grade research networks.

I reverse-engineered the protocols, mapped network topologies, documented everything. By 13, I had a deeper understanding of internet infrastructure than most professionals working in the field. The dark web taught me one thing: there are layers to everything. The surface is just the beginning.

The Indian Computing Science Olympiad (ICSO), organized by SOF, became my annual challenge. Every year, I competed. Every year, I won.

But I never hit 100%. Not because I couldn't — but because school timings and study pressure meant I couldn't give it my all. The real challenge wasn't the competition. It was balancing academics with passion.

ICSO taught me something important: it's not about being the best. It's about showing up, competing, and improving every year. Consistency beats perfection.

I started building. Not just code — entire systems. Real-time log analytics engines. Vulnerability intelligence platforms. Neural network playgrounds. GitHub analytics dashboards.

Every project was built from scratch. No AI code generation. No GitHub Copilot. No ChatGPT. Every line of code written by hand, tested by hand, deployed by hand.

191 repositories. 201 stars. 631 commits. 114 pull requests. Numbers that most adults with decades of experience haven't reached. And I'm 15.

But numbers aren't the point. The point is understanding. Every repo taught me something — about architecture, about design patterns, about trade-offs, about the difference between code that works and code that's good.

Contributing to open source isn't just about code — it's about community, collaboration, and leaving things better than you found them.