APILama

Every few years, a technology shows up that lets a small team operate like a much bigger company. I’ve been lucky enough to live through ten of them. This is what they looked like from the inside.

People talk about technology revolutions like they’re chapters in a textbook. For me they’re autobiographical. Each one arrived while I was trying to build something, and each one changed what I could build. Looking back, they all did the same thing in different costumes: they collapsed the distance between having an idea and operating like a company ten times your size.

Here they are, in the order I lived them.

1. The Silicon Floor (2005)

I entered the National Technical University of Athens in 2005, right at the end of the gigahertz wars. The lab machines were Pentium 4s — Intel had spent a decade making the same chip faster, and it had just hit a wall. What came next was the real revolution: within a year, Core Duo and then Core 2 Duo put multiple cores in ordinary machines, and “how do I make this parallel?” stopped being a supercomputing question and became a student’s homework problem.

That same year I installed Debian for the first time. Linux plus commodity Intel hardware meant something profound that I only understood later: the operating system and the silicon underneath every serious system in the world were now things an 18-year-old in Athens could own, inspect, and break. We set up our first servers in the lab and realized nothing about “server” was magic. It was just a computer that stayed on.

That was the floor everything else was built on. Every revolution since has been an abstraction layer on top of cheap x86 and open-source Unix.

2. The Battery That Freed Me (2008)

In 2008 I bought a MacBook — the all-white polycarbonate one. Everyone remembers Apple for design. I remember it for the battery.

It sounds absurd now, but a laptop that reliably lasted several hours changed my working life more than any framework did. Before that, a laptop was a desktop you could move between power outlets. After it, my office was wherever I sat down: the NTUA library, a café, an airport. Unix underneath, a full day of work on a charge, and suddenly “where do you work?” became a meaningless question.

The lesson stuck with me permanently: the revolution is rarely the spec everyone benchmarks. It’s the constraint that quietly disappears.

3. The Commit That Ate the World (2005–2008)

Two things happened almost silently in this period: Linus Torvalds wrote Git in 2005 to manage the Linux kernel, and in 2008 GitHub wrapped it in a social network.

It’s easy to forget what came before. Version control meant SVN servers someone had to administer, merges you scheduled like dental surgery, and code that lived inside company walls. Git made branching free; GitHub made sharing the default. Together they turned open source from a movement into infrastructure — the place where software actually gets built.

Every revolution that follows in this essay runs on this one. Docker images are built from GitHub repos. The Python and JavaScript ecosystems are pip and npm pulling from public repositories. Even the LLMs writing code today learned from the world’s biggest corpus of shared software. Git and GitHub did for collaboration what the cloud later did for infrastructure: they made the coordination capacity of a thousand-person company available to anyone with a laptop.

4. Servos, Arduino, and the Robot That Had Facebook Friends (2009–2011)

In 2009 a scholarship took me to the UAE, to the Interactive Robots and Media Lab (IRML), working on social humanoid robots. Robotics is where hardware humbles you: half of the “intelligence” of a robot lives in servo motors, and the innovation happening in servos at the time — cheaper, more precise, digitally controlled — mattered as much as any algorithm we wrote.

And then there was Arduino. It’s hard to overstate what it did. Before it, making a motor move meant custom boards, real electronics expertise, and budget. After it, a $30 board and twenty lines of code. Arduino did to hardware what Linux had done to servers: it removed the priesthood. A few years later the Raspberry Pi finished the job — a full Linux computer for $35. I ended up building an operating system for televisions on top of one. A computer that cheap made “let’s just try it” the default engineering strategy.

5. The Language Reshuffle (2010–2014)

I learned C as a student, the way you learn Latin: for discipline. But in 2010, working on robotics and AI, I switched to Python and never really left. Python won robotics and machine learning for the same reason Arduino won hardware: it collapsed the time between an idea and a running experiment.

Meanwhile JavaScript rode the web and mobile waves from “toy language” to the most deployed runtime on Earth. The interesting story, though, is the language that didn’t die. Java watched the big data explosion happen largely on its own virtual machine — Hadoop, Kafka, Spark — and then Java 8 arrived in 2014 and absorbed the lessons: lambdas, streams, a functional style built for data pipelines. That’s why entire national tech markets — Greece included — still run deep benches of Java engineers today. The ecosystem that takes enterprise data seriously never stopped hiring.

Languages don’t win on elegance. They win on which revolution they attach themselves to.

6. Mobile Broke the Server (2008–2012)

The iPhone gets remembered as a consumer story. For those of us on the backend, it was an architectural earthquake.

Suddenly every product needed to serve not just a website but an iOS app, an Android app, and whatever came next — all from the same backend, all over flaky cellular connections. The pragmatic answer was REST APIs, shipped in volume and in a hurry. Mobile didn’t politely encourage the API economy; it forced it into existence. Every company on Earth had to expose its guts over HTTP, ready or not.

And then the APIs themselves became the product. Stripe turned payments into seven lines of code; Twilio did the same for telephony. A generation of companies realized their entire business could be an API — capabilities you once built a department for became a credit card and an API key. If mobile forced companies to expose interfaces, Stripe and Twilio proved the interface could be the whole company.

That earthquake set the course of my academic life. My PhD research at NTUA became an obsession with APIs — not as plumbing, but as the layer where machines negotiate meaning. I’ve written elsewhere about how that research anticipated the agentic web. None of it would have happened if mobile hadn’t broken the monolith first.

7. The Elephant (2012–2015)

During my PhD I worked on an EU research project doing social media analytics, and that’s where I stood up my first Hadoop cluster with my own hands.

It’s difficult to convey to anyone who arrived after Spark what Hadoop meant. Before it, analyzing data bigger than one machine was something Google did, described in papers the rest of us read like science fiction. Hadoop took MapReduce and HDFS and made them something a PhD student could run on a rack of commodity boxes. “Big data” stopped being a capability and became a download.

The elephant traveled with a herd. The same era gave us NoSQL — MongoDB, Redis, Cassandra — because once your data outgrew one machine, the relational guarantees we’d treated as laws of physics turned out to be design choices. I lived the whole arc: raw MapReduce jobs, Hadoop orchestrated from Python, then Spark — where I wrote most of my jobs in Scala — making the whole thing fast and almost pleasant. Every analytics platform, every recommendation engine, every “data-driven” anything traces back to that yellow elephant. And, less obviously, so does modern AI: the discipline of training models on massive datasets was rehearsed for a decade on Hadoop clusters before the GPUs took over.

8. Renting a Skyscraper by the Hour (2007–2015)

If I had to pick the single most consequential revolution of the lot, it isn’t the flashiest one. It’s the cloud.

It had a quiet enabler people forget: virtualization. VMware and Xen spent the early 2000s proving that “a server” could be software — an illusion running beside other illusions on shared hardware. Without that trick, EC2 is impossible. Then EC2 and S3 arrived, Heroku put a deploy behind a git push, and together they ended the era where infrastructure was a capital expense. I remember the exact feeling: we could scale as if we owned a building full of servers, except the building materialized when traffic arrived and vanished when it left. A three-person team could suddenly answer the question “what happens if a million users show up?” with something other than panic.

Everything I later did as a CTO rests on this. Scaling ORFIUM from zero to hundreds of engineers across seven offices would have been fantasy in a datacenter-ownership world. The cloud is what made small teams operationally equal to big companies — the purest expression of the pattern this whole essay is about.

9. Shipping Containers (2013–2018)

Docker arrived in 2013 and solved a problem so old we had stopped noticing it was a problem: “works on my machine.” Packaging an application with its entire world into an image that runs identically everywhere sounds mundane. It was a phase change.

Because once applications became standardized boxes, an entire innovation wave stacked on top: Kubernetes to orchestrate thousands of them, Istio and service meshes to govern how they talk, CI/CD pipelines that treat production deployment as a boring, hundred-times-a-day event. At Orfium, this stack is what let autonomous teams ship independently without stepping on each other. Docker didn’t just change deployment; it changed organizational design. Microservices are Conway’s Law with a container runtime.

10. The Revolution That Talks Back (2022–now)

And then software started understanding us.

There’s a silicon story hiding inside this one, and it closes the loop this essay opened. NVIDIA released CUDA in 2007 so that graphics chips could do general math, and for a decade it looked like a niche tool for physicists and gamers. Then it turned out that the same operation that renders pixels — multiplying enormous matrices in parallel — is the operation that trains neural networks. My generation’s story started with Intel making computing cheap; it hits its crescendo with NVIDIA making intelligence computable. The 2005 chapter and this one are the same chapter, twenty years apart.

I spent years in the semantic web trenches trying to make machines reason over formal logic, so I can say this with some authority: LLMs achieved what a decade of ontologies couldn’t, by trading precision for probabilistic intuition. This wave — agents, orchestration, what I call vibe coding — is the one I’m living right now as CTO at Dialectica, and it’s the first revolution that compounds all the previous ones. It runs on cloud infrastructure, ships in containers, speaks APIs, and was trained with big data discipline.

It’s also the steepest leverage curve I’ve ever seen. Every previous revolution let a small team operate like a bigger company. This one lets a single person operate like a team.

The Revolutions That Weren’t

Honesty requires a confession: not every wave I watched turned out to be one.

I watched blockchain promise to re-architect trust itself, absorb a decade of the industry’s brightest engineers, and produce — mostly — speculation about its own tokens. I watched VR be declared the next computing platform roughly every four years since I was a student. Both had the aesthetics of a revolution: conferences, evangelists, toys that demoed brilliantly. What they lacked was the thing every entry on my list shares — each one quietly removed a constraint for people building something else. Nobody’s product got dramatically cheaper to build because of an NFT.

That’s the test I’ve settled on. A real revolution is infrastructure for other people’s ambitions. A false one is a destination that keeps asking you to move in.

The Pattern

Lay the ten waves side by side and the shape is unmistakable. Linux and Intel made serious computing ownable. Git and GitHub made planet-scale collaboration free. Arduino and Raspberry Pi made hardware hackable. Python made experiments cheap. Mobile forced every system to open an interface — and Stripe proved the interface could be the company. Hadoop made industrial-scale data a student project. The cloud made infrastructure rentable by the hour. Docker made shipping boring. GPUs and AI are making expertise itself elastic.

Every revolution made technology more accessible — and with every wave, I could operate as if I were a much larger organization with far more resources. That is the entire twenty-year story in one sentence. The tools changed; the gift was always leverage.

Which means the only real career skill is recognizing the next wave while it still looks like a toy. Arduino looked like a toy. Docker looked like a toy. LLMs looked like a toy that hallucinated. The trick is telling those toys apart from the blockchain kind — and the test above is the best one I have. Ask what constraint the toy removes for someone building something else. If the answer is “none, but the demo is incredible,” walk away.

The toys are the revolution. They always were. Just make sure the toy is a tool.