The developer deployed code that ran without servers.
“Look,” they said, “no infrastructure to manage!”
The senior developer smiled, “If there are no servers, what is serving your code?”
And, “When you remove the server, where does it go?”
Beyond the Surface
The serverless paradigm represents one of modern development’s most seductive abstractions. We write functions, deploy them with a single command, and never think about CPU allocation, operating system patches, or load balancing. The infrastructure simply vanishes from our concern—or does it? The senior developer’s first question cuts to the heart of our relationship with abstraction: “If there are no servers, what is serving your code?” Of course, servers still exist. They’re running in data centers, consuming electricity, generating heat, requiring cooling systems and maintenance staff. The servers haven’t disappeared—we’ve just delegated their care to someone else.
This delegation is the entire point of serverless computing, and there’s genuine value in it. By removing infrastructure management from our immediate concerns, we can focus on business logic and user value. But the koan asks us to remain conscious of what we’re trading. The second question deepens the inquiry: “When you remove the server, where does it go?” This isn’t about physical location—it’s about understanding that removal from our view is not removal from existence. The complexity doesn’t vanish, it moves. The responsibility doesn’t disappear, it transfers. The costs don’t evaporate, they’re restructured and sometimes hidden in ways that surprise us later.
There’s a broader lesson here about all abstractions in software development. Every framework that “handles everything for you,” every library that “just works,” every platform that “takes care of the details”—they all move complexity rather than eliminate it. Sometimes they move it to a better place. Sometimes they just move it out of sight. The mindful developer practices gratitude for good abstractions while maintaining awareness of what lies beneath. We don’t need to manage our own servers to build most applications, but we benefit from understanding that servers still exist, that our code runs on physical hardware, that someone somewhere is handling the complexity we’ve abstracted away.
The koan invites us to hold two truths simultaneously: abstractions are valuable and necessary for progress, yet what we abstract away continues to exist and matter. When we remove something from our immediate concern, we should at least know where it went and who now carries it. What other abstractions in your development practice have moved complexity out of your view? Where did that complexity go? And does it matter that you’re no longer seeing it?