From DOS to Cloud: My 33-Year Journey with Tech — From an Amiga in 1994 to Deploying on Railway with Next.js

There's a photo of me from 1994 that my mom keeps in a green plastic album. I'm three years old, bowl cut, sitting in front of an Amiga 500 with an expression of absolute concentration. I have no idea what I was looking at. Probably some game on a floppy my dad had copied from god knows where. But that image is my origin story. The personal big bang of this Argentine programmer's journey — one that started before I could even read.

The Amiga wasn't a computer. It was a universe.

The Commodore Amiga 500 was a machine that was technically dead in the global market by 1994, but in Argentina — land of glorious setbacks — it was still alive and kicking. My dad had gotten one through some kind of trade that only existed in nineties Argentina, the kind of deal you can't fully explain to anyone who wasn't there.

It had 512KB of RAM. It ran a multitasking operating system at a time when Windows was still a pathetic shell sitting on top of DOS. It played 8-bit audio samples when IBM PCs could barely manage a beep. It was, objectively, a superior machine that the market abandoned for political and commercial reasons I still consider a crime.

I didn't understand any of that. I just knew that when you turned on that gray box and slid in the kickstart disk, an impossible-for-its-time explosion of color appeared on screen and the world opened up.

That's where it all started.

At age 5: my first domain (and I had no idea what that even meant)

This sounds like I'm making it up, but I'm not. My dad, who worked in something related to imports and exports, had started getting into the internet around 1996. By 1998, when I was 5, we had a dial-up connection and he'd let me mess around on the computer.

I registered my first domain — well, he registered it, I told him the name — because I wanted "my own place on the internet" to post drawings. I had absolutely no idea what a domain actually implied. To me it was like putting your name on a bedroom door.

But that intuition — that the name matters, that digital space is yours if you claim it — got burned into me permanently.

Age 14 and the Palermo internet café: where I learned networking the hard way

Here's the visceral part.

It was 2005. Argentina was crawling out of the 2001 economic crisis with broken ribs but a will to live. Internet cafés were the technological heartbeat of every neighborhood. There was no WiFi everywhere, the government laptop program didn't exist yet, and if you wanted to play Counter-Strike with your friends or download music from Ares (yes, Ares, no regrets), you went to the cyber café.

I got a job at one. I was 14, had zero formal qualifications, and the owner — a guy in his mid-forties who'd built the business with his savings — hired me because I was the only one who could restart the server when it crashed without breaking anything else in the process.

That's where I learned networking. Not from a book. I learned because when the connection dropped at 10PM with a full house of kids screaming that they'd lost their match, you had to diagnose and fix it right now.

I learned what a DHCP server was when the Windows 2000 box stopped assigning IPs and every machine got stuck with APIPA (169.254.x.x — that address range gives me PTSD to this day). I learned what a switch was, what a hub was, the difference between the two, and why hubs were garbage for gaming (packet collisions, unpredictable latency). I learned to configure basic VLANs on second-hand Cisco switches the owner had picked up at a flea market.

No book taught me that. Pressure taught me that. Adrenaline taught me that. The very real fear of getting fired taught me that.

At 18: Linux, web hosting, and my first technical existential crisis

I jumped from the internet café to the world of web hosting. 2009. Fibertel was becoming a real thing, WordPress existed but people were still building sites in Dreamweaver, and PHP 5 was the cutting edge.

I installed my first Linux server on physical hardware. A Pentium 4 repurposed as a server running Ubuntu Server 8.04. No GUI. Just terminal.

I remember the exact moment I brought up my first VirtualHost in Apache:

<VirtualHost *:80>
    ServerName myfirstdomain.com.ar
    DocumentRoot /var/www/myfirstdomain
    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

Sounds like nothing. But when you write that config, run sudo service apache2 reload, open the browser and your domain loads from your own machine... something in your brain clicks. You understand, at a visceral level, how the internet actually works. Not as an abstract concept. As real infrastructure that you are controlling.

That feeling? I wouldn't trade it for anything.

I also broke things constantly. I misconfigured a mail server and ended up on spam blacklists. I deleted /var/www entirely with a poorly typed rm -rf (yes, it happened, yes, I wanted to disappear). I learned what a backup was after desperately needing one. All lessons no tutorial can teach you, because you only learn them when the pain is real.

The CCNA and university: trying to formalize the chaos

I studied for the Cisco CCNA because I felt like my knowledge was an archipelago of islands with no bridges between them. I could do things but I didn't understand the complete architecture. The CCNA gave me the theoretical framework that organized all the noise.

The OSI model. The TCP/IP stack. Spanning Tree Protocol. OSPF. BGP in its most basic forms. Everything I'd touched empirically suddenly had a name, a structure, a reason for existing.

Then I enrolled in Computer Science at UBA (University of Buenos Aires). And that broke my brain in a different way. Algebra, calculus, algorithms, computational complexity. The difference between O(n) and O(n²) isn't academic — it's the difference between an app that scales and one that dies under load.

UBA taught me how to think. The internet café had taught me how to do. I needed both.

2020: The pivot. The year that changed everything.

The pandemic hit and, like a lot of people, it locked me in with time and questions. I was doing infrastructure work, sysadmin, some DevOps. But software development had always called to me and I'd always put off making the jump.

In March 2020, with the world on fire, I decided: now.

I started with vanilla JavaScript. Then React. Then TypeScript — and at first I hated it. Everyone hates TypeScript at first. Anyone who says otherwise is lying.

Then Next.js.

The first React component I ever wrote was terrible:

// This is archaeology. Don't judge.
function MyComponent() {
  var name = "Juan";
  return (
    <div>
      <p>Hello {name}</p>
    </div>
  )
}

No hooks. No TypeScript. Nothing. But it worked, and that was enough to keep going.

After months of iteration, that same component started looking like this:

interface GreetingProps {
  userId: string;
  fallbackName?: string;
}

const Greeting: React.FC<GreetingProps> = ({ userId, fallbackName = 'friend' }) => {
  const { data: user, isLoading } = useUser(userId);

  if (isLoading) return <Skeleton className="h-6 w-32" />;

  return (
    <p className="text-lg font-medium">
      Hello, {user?.displayName ?? fallbackName}
    </p>
  );
};

export default Greeting;

The distance between those two code snippets is the distance between not knowing and starting to know. And that distance is measured in hours of frustration, in Stack Overflow at 2AM, in TypeScript errors you don't understand until suddenly you understand everything.

Today: Docker, PostgreSQL, Railway, and the deploy that makes me feel powerful

Today my stack is Next.js 14, TypeScript, PostgreSQL with Prisma, Docker for local development, and Railway for production. And when I deploy a complete app — with its database, its environment variables, its custom domain — I still feel something. I don't know if I'd call it pride or just deep satisfaction.

My typical development docker-compose.yml:

version: '3.8'
services:
  app:
    build:
      context: .
      dockerfile: Dockerfile.dev
    ports:
      - "3000:3000"
    volumes:
      - .:/app
      - /app/node_modules
    environment:
      - DATABASE_URL=postgresql://postgres:postgres@db:5432/myapp
    depends_on:
      - db

  db:
    image: postgres:15-alpine
    ports:
      - "5432:5432"
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_DB=myapp
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

That's reproducible infrastructure. Any dev on the team runs docker compose up and gets the exact same environment. No "works on my machine." No phantom dependencies.

There's a direct line between configuring Apache on Ubuntu 8.04 in 2009 and writing that docker-compose.yml in 2024. It's the same obsession — understanding how the pieces fit together.

What 33 years of technology actually taught me

There are no shortcuts to technical intuition. You can learn syntax over a weekend. Intuition — knowing why something is failing before you read the error, understanding how a system is going to scale, anticipating the edge cases — that's built with time and with pain.

My story isn't a story of genius. It's a story of accumulated exposure. Of being close to technology from such an early age that the layers of abstraction slowly became transparent.

Every mistake I made — the rm -rf, the broken configs, the mail servers on blacklists — left something behind. A scar that is now knowledge.

And the Amiga 500. I always come back to the Amiga. That machine that did more with less, that was technically superior and lost anyway, that was still alive in Argentina when the rest of the world had moved on — it taught me something without me even realizing it: in tech, the best doesn't always win. What wins is what gets adopted, pushed, made your own.

That's what I do. Have been doing it for 33 years. And I'm not stopping.