The software that runs a huge share of the internet’s applications today traces back to a secretive internal Google system — one named, with a straight face, after the cybernetic villains from Star Trek. The story of how Google’s Borg became Kubernetes is one of the most consequential — and least-known — episodes in modern tech history: a company took the crown jewels it had used to run Search, Gmail, and YouTube, rebuilt them in the open, and gave them away to the entire industry.
Here’s how that happened — the systems, the people, and the Star Trek jokes hiding in plain sight in Kubernetes to this day.
Borg: Google’s Secret Weapon
Long before anyone outside Google had heard the word “Kubernetes,” Google had a problem no one else had at quite that scale. It needed to run everything — Search, Gmail, Maps, YouTube — across enormous fleets of ordinary machines, keeping it all alive as individual servers constantly failed. Doing that by hand was impossible.
So, starting in the mid-2000s, Google built an internal system to do it automatically. They called it Borg — after the Star Trek Borg collective, the hive-mind that assimilates everything into one relentless whole. It was a fitting name: Borg pooled tens of thousands of machines into what behaved like one giant computer, packing hundreds of thousands of jobs onto them and healing failures without humans watching.
For roughly a decade, Borg was one of Google’s most important pieces of infrastructure — and almost nobody outside the company knew it existed. Google finally described it publicly only in 2015, in a research paper. By then, it had already quietly inspired something bigger.
Omega: The Research Detour
Around 2013, Google engineers built a second, more experimental cluster-management system called Omega, exploring a more flexible design where multiple schedulers could work on the same shared view of the cluster at once. Omega was never the star of the show, but its ideas mattered: they flowed both back into Borg and forward into what came next. Think of it as the bridge between the secret internal system and the open one about to be born.
Kubernetes: Borg, Reborn in the Open
In 2014, a small group of Google engineers — Joe Beda, Brendan Burns, and Craig McLuckie — started a new project to build an open-source system that captured a decade of Borg’s hard-won lessons, but for everyone. Many of its early contributors were Borg and Omega veterans, so the DNA carried straight over. They named it Kubernetes.
An important nuance, because it’s often garbled: Kubernetes is not literally Borg. Google didn’t open-source Borg itself. Kubernetes is a from-scratch successor — a clean re-implementation inspired by Borg’s ideas, freed from Google’s internal specifics. That distinction is why it could become a shared industry standard rather than a Google-only tool.
The milestones came fast: Kubernetes was open-sourced in 2014, hit version 1.0 in July 2015, and — crucially — Google donated it to a brand-new, neutral home called the Cloud Native Computing Foundation (CNCF) as its very first project. In 2018 it became the first CNCF project to formally “graduate.” Handing its crown jewels to a vendor-neutral foundation, rather than keeping control, is a big part of why Kubernetes won.
The Star Trek Jokes Hiding in the Logo
Here’s the fun part that almost nobody notices. The name Kubernetes comes from the Greek word for “helmsman” or “pilot” — the person who steers a ship. (It’s the same root as “cybernetics” and “governor.”) That’s why the Kubernetes logo is a ship’s wheel.
But look closer: the wheel has exactly seven spokes. That’s a deliberate wink. Before it went public, the project’s internal codename was “Project Seven” — a reference to Seven of Nine, a character from Star Trek: Voyager who was a former member of… the Borg. So the seven-spoked helm is a quiet tribute to the secret system Kubernetes grew out of. And “K8s,” the common shorthand, is just a “numeronym”: a K, the eight letters “ubernete,” and an s.
Why It Took Over the World
Kubernetes didn’t win because it was the only container orchestrator — several existed. It won because of a combination that was hard to beat:
- It was open and vendor-neutral. Governed by the CNCF rather than a single company, no one had to fear lock-in to a competitor.
- It packaged real production wisdom. This wasn’t a theoretical design; it distilled a decade of Google running planet-scale systems.
- It grew a massive ecosystem. Every major cloud raced to offer managed Kubernetes (Google’s GKE, Amazon’s EKS, Microsoft’s AKS), and a whole industry of tools grew around it. Network effects did the rest.
Within a few years, a secret system with a Star Trek villain’s name had become the closest thing the software industry has to a universal standard for running containers at scale.
The Bigger Lesson
Step back and the remarkable thing isn’t the technology — it’s the choice. Google took infrastructure it could have kept as a private competitive advantage and rebuilt it as a free, open, community-governed standard. That decision reshaped how the entire industry deploys software, created an enormous ecosystem, and arguably did more for Google’s cloud ambitions than hoarding Borg ever could have. Sometimes the most powerful move is to give the crown jewels away. (Just remember, as we cover in what Kubernetes is: powerful as it is, you often don’t need it for a small app.)
❓ Frequently Asked Questions
Is Kubernetes the same as Google’s Borg? No. Kubernetes was inspired by Borg, Google’s internal cluster-management system, and built by some of the same engineers — but it’s a separate, from-scratch open-source project, not Borg itself. Google never open-sourced Borg; it created Kubernetes as a clean successor that anyone could use.
What was Borg? Borg was Google’s internal system, built starting in the mid-2000s, for running its software (Search, Gmail, Maps, YouTube, and more) across huge fleets of machines automatically — scheduling jobs, restarting failures, and treating thousands of servers as one pool. Google kept it private and only described it publicly in a 2015 research paper.
Why is Kubernetes called Kubernetes? The name is Greek for “helmsman” or “pilot” — someone who steers a ship — which is why its logo is a ship’s wheel. It’s related to the words “cybernetics” and “governor.” The common abbreviation “K8s” replaces the eight letters between the K and the s with the number 8.
Why does the Kubernetes logo have seven spokes? It’s a Star Trek in-joke. The project’s internal codename before launch was “Project Seven,” after Seven of Nine — a character who was formerly part of the Borg collective. The seven-spoked ship’s wheel is a nod back to Borg, the Google system Kubernetes descended from.
Who created Kubernetes? Kubernetes was started at Google in 2014 by engineers Joe Beda, Brendan Burns, and Craig McLuckie, with many early contributors who had worked on Borg and Omega. Google open-sourced it and donated it to the Cloud Native Computing Foundation as that foundation’s first project.
📚 Keep Learning
- What Is Kubernetes? — what this system actually does, in plain English.
- What Is a Container? — the thing Kubernetes orchestrates.
- How to Deploy a Container to the Cloud — including the simpler options that often beat Kubernetes.
📚 Recommended Resources
Disclosure: some links below are Amazon affiliate links. If you buy through them, I earn a small commission — at no extra cost to you — which helps keep this site running.
The Kubernetes Book
Nigel Poulton · Book · ~$30 on Amazon
Loved the story and want to actually understand the system Google gave the world? This is the best-selling, regularly-updated guide — the clearest way to go from “I know where Kubernetes came from” to “I can use it,” built up from the fundamentals.
The Phoenix Project
Gene Kim, Kevin Behr & George Spafford · Book · ~$20 on Amazon
For the human story behind why systems like Borg and Kubernetes exist — the pressure to ship reliable software at scale — this page-turning novel is the most enjoyable way in. No jargon, just the drama of modern IT.