There's a photo I don't have but that exists perfectly sharp in my memory: me, 1994, just turned three years old, standing in front of a Commodore Amiga 500 holding a joystick that was comically oversized for my hands. My dad had brought that machine from God knows where, and I had absolutely no idea what was happening on the screen. But something about that monitor — the colors, the sound, the idea that I could make things happen — hooked me in a way that never let go.
That was thirty-one years ago. And here I am.
The Amiga as my first teacher
The Amiga 500 wasn't a Windows machine or a DOS box. It was its own beast — AmigaOS, a graphical interface at a time when most of the world was still typing commands into green screens. I obviously knew none of that. What I knew was that if you grabbed the right floppy and shoved it into the drive, a game appeared. And if you did something wrong, you got the Guru Meditation — that terrifying red error screen that, to five-year-old me, meant the machine was dying.
But the Guru Meditation was my first real contact with the idea that computers fail. That they're not magic. That there's something inside that can break. That intuition — which years later became actual knowledge — is probably the most valuable thing that old, beat-up Amiga ever gave me.
By age 5 I already had my first domain. No, that's not a joke. My dad was part of that generation that understood the internet before anyone else in Argentina did, and somehow I was already in that world too. I didn't understand what DNS was or why it worked, but I knew that name was mine and that it pointed to something on the internet. The seed of nerd pride was planted.
Internet cafés as my university
Let's skip the usual chaos of growing up in Argentina in the '90s and jump to age 14. I was working at internet cafés. And when I say working, I don't mean running the register — I mean under the desks, pulling cables, configuring Windows 98 (which broke by just looking at it the wrong way), installing network drivers that barely existed for hardware that probably shouldn't have existed either.
Internet cafés back then were a jungle. Ten machines wired together with raw UTP cable, cheap hubs that ran hot as ovens, pirated Windows that occasionally decided the perfect moment to reboot was mid-Counter-Strike match. My unofficial job was keeping everything alive. And I learned more about networking in six months at an internet café than in any formal course.
I learned what a subnet was because I had to configure them. I learned what DHCP was because when it broke, kids couldn't play and they'd yell at me. I learned what a MAC address was because it was the only way to figure out which of those ten machines was always the one crashing. Knowledge forced by chaos is the knowledge that sticks.
Linux at 3am and my first real server
At 18 the jump was to web hosting on Linux. And this is where things got serious.
Installing Linux in 2009 was nothing like it is today. There was no friendly installer holding your hand. You calculated partitions manually, you had GRUB that — if you misconfigured it — would leave you with no bootable OS on any of your drives, and you had network drivers that sometimes flat-out didn't exist for your hardware and had to be compiled from source code downloaded on the one machine in the house that actually had internet.
But once it was running... it was mine. Completely mine. A server running Apache, MySQL, PHP — the LAMP stack that powered half the internet back then. Configuring virtual hosts at 3am because that was the only time I could work without interruptions. Watching logs scroll in real time with tail -f like it was telemetry from a spacecraft.
That feeling — having a real machine on the internet, serving requests from real people — never goes away. It's addictive. I get that same feeling today when I deploy and watch Railway's logs update in real time, but the first time I felt it I was 18 years old and it was on a physical server in some datacenter I never once laid eyes on.
The detour: Cisco CCNA and university
There was a period where I went deeper into networking than software. I did the Cisco CCNA certification — one of those credentials that makes you study routing protocols, spanning tree, VLANs, and subnetting until you're dreaming about it — and I enrolled in Computer Science at the UBA (University of Buenos Aires).
The UBA taught me how to think. That sounds like a cliché but it's literal. Algebra, logic, algorithms — the side of computing you don't learn by messing around with servers. I learned why certain algorithms are more efficient than others. I learned how to prove things. I learned that there's a massive difference between code that works and code that is correct.
I also learned that Argentine academia has a complicated relationship with the real-world tech industry. We were studying compiler theory while outside, the world was exploding with Node.js and the first startup boom. I don't regret it — the theoretical foundation is worth gold — but there was a disconnect that sometimes drove me crazy.
The CCNA, on the other hand, was brutal in the best way. Studying for that certification is like getting inside the heads of Cisco's engineers and understanding why the internet works the way it does. Why packets take certain routes. Why it breaks when it breaks. That low-level network knowledge — today, when I'm debugging connectivity issues in Docker or configuring firewall rules on a VPS, I still use it constantly.
2020: the pivot that changed everything
And now we get to the moment that changed everything. 2020. Yeah, that year.
With the world on a forced pause, I made the decision to go all-in on modern software development. Not as a hobby — as my main career. And the world I found was unrecognizable compared to the PHP I'd touched a decade earlier.
React. TypeScript. Next.js. Docker. PostgreSQL. A completely different ecosystem with its own conventions, its own internal arguments (Redux or Context? REST or GraphQL? tabs or spaces — okay, that one's settled), its own culture.
The first month was humbling. Me — someone who had configured Linux servers, who understood how TCP/IP works, who had studied algorithms at university — couldn't get a React component to work without breaking everything around it. The mental model is completely different. Reactive state, component lifecycles, TypeScript's type system that at first feels like an obstacle and then you realize it's the thing that saves your life — all of it was new.
But this is where those thirty prior years paid dividends. When something broke, I knew how to read the error. When there was a network issue inside Docker, I knew what was happening. When the database was behaving weirdly, I had intuition for where to look. The accumulated experience wasn't directly transferable, but it created a context that absolutely accelerated learning.
Railway, Next.js, and deploying in 2024
Today my stack is Next.js with TypeScript, PostgreSQL for persistent data, Docker so my local environment matches production (the eternal promise that Docker actually delivered on), and Railway for deployments.
Railway deserves its own paragraph because it perfectly captures the contrast with where I started. In 2009, putting something in production meant: renting a server, configuring it from scratch over SSH, installing the entire stack, setting up the domain, configuring SSL manually with Let's Encrypt or paying for a certificate, setting up backups, monitoring... Days of infrastructure work before you could ship a single line of product code.
With Railway today: railway up. Done. Seriously. The infrastructure is fully abstracted. PostgreSQL with one click. Environment variables in a UI. Automatic deploys from GitHub. Automatic SSL. Monitoring included.
The first time I did a deploy like that, I just stared at the terminal in silence for a few seconds. I thought about the nights configuring Apache, about broken GRUBs, about internet cafés in December heat with cables everywhere. And I thought: this is too easy. Then I corrected myself: it's not easy — someone else did the hard work for you.
That's the paradox of technological abstraction. Everything becomes more accessible, and that's genuinely good — it means more people can build things. But it also means there are layers of complexity that go invisible, and when something goes wrong in those layers, the developer who never touched a physical server doesn't have the mental tools to understand what's happening.
Why where you come from matters
I'm a weird product of my era: too young to have lived the mainframe days, too old to have started with smartphones and YouTube tutorials. I landed right in the middle of the biggest transition in the history of personal computing.
And that gave me something I value more and more as time goes on: historical context. I know why things are the way they are. I know why Docker exists — because "works on my machine" is a real problem I lived through. I know why TypeScript exists — because JavaScript at scale is a maintenance nightmare I also lived through. I know why cloud services exist — because the alternative was what I was doing at 18.
This story — an Argentine developer who grew up alongside the technology in real time — isn't nostalgia. It's context. And context is what separates someone who uses tools from someone who understands them.
The Amiga 500 of 1994 and Railway in 2024 are the same continuum. Everything changed and nothing changed: it's still about making machines do what you want them to do. It's still about understanding what's happening when something breaks. It's still about that feeling — addictive, visceral, singular — of watching something you built actually work in the real world.
Three years old. An Amiga. Thirty-one years later, still here.
