This post first appeared in The Analytics Engineering Roundup.
In this season of the Analytics Engineering podcast, Tristan is digging deep into the world of developer tools and databases. There are few more widely used developer tools than Docker. From its launch back in 2013, Docker has completely changed how developers ship applications.
In this episode, Tristan talks to Solomon Hykes, the founder and creator of Docker. They trace Docker’s rise from startup obscurity to becoming foundational infrastructure in modern software development. Solomon explains the technical underpinnings of containerization, the pivotal shift from platform-as-a-service to open-source engine, and why Docker’s developer experience was so revolutionary.
The conversation also dives into his next venture Dagger, and how it aims to solve the messy, overlooked workflows of software delivery. Bonus: Solomon shares how AI agents are reshaping how CI/CD gets done and why the next revolution in DevOps might already be here.
Please reach out at podcast@dbtlabs.com for questions, comments, and guest suggestions.
Listen & subscribe from:
Key takeaways
Tristan Handy: I want to get you to give a little background on yourself, where you've been, what you've been up to for the last couple decades. I think many people will know you as the person who kicked off an avalanche that changed how we interact with compute environments by inventing Docker?
Solomon Hykes: Docker is the thing I'm known for. Pre-Docker, I grew up in France. I studied programming in a French school called EpiTech. It was a brand-new, unconventional school where you learned through nonstop programming, which I loved.
Eventually, I got exposed to startups, despite being a complete outsider. I met someone who told me about them, and it stuck in my mind. Still in France at the time, I moved into my mom's house in the suburbs of Paris and worked out of the basement.
By complete luck, I got into an early version of Y Combinator in 2010. That got us on the path to what would become Docker three years later. In 2013, we pivoted to Docker from our previous company, dotCloud.
Tristan Handy: The original thing was called dotCloud, right?
Solomon Hykes: Yep. It was about container technology and its potential, but we didn't quite know how to take it to market. DotCloud was about deploying and hosting people's apps—platform as a service—competing with Heroku and many clones.
Tristan Handy: When did Heroku become a thing?
Solomon Hykes: I became aware of it in 2009. Just as I was struggling in France with container tech. When we joined YC in 2010, we packaged that tech into dotCloud, our hosting platform. Our differentiator was using containers under the hood when others didn’t. That let us support many language stacks and even run databases in containers—which was unheard of at the time.
Platform as a service was a tough business. Most startups went out of business or got acquired early. Eventually, we pivoted from selling the car to building an ecosystem around the engine—that became Docker.
Tristan Handy: Did you pivot because selling the car wasn't working? Or because people kept pointing at the engine saying, “Give me that”?
Solomon Hykes: Both. It was hard to market platforms. Developers expected free hosting, and hosting costs money. Margins were tight because of AWS. It always felt like pushing a boulder uphill. Meanwhile, people wanted to run things locally. There was no good ecosystem for that. Docker provided transparency, flexibility, and portability.
Tristan Handy: Can you define Docker and containerization, and how it differs from virtualization?
Solomon Hykes: Sure. Virtualization splits a physical machine into virtual ones using VMs—each with its own memory, compute, and storage. It gives flexibility, but with overhead.
Containerization does something similar but at the operating system level. Instead of virtualizing the machine, you split the OS itself. It’s mostly done with Linux, which can subdivide itself into isolated units. Containers are more lightweight, letting you run hundreds or thousands, unlike VMs where you might manage a handful before hitting limits.
Docker didn’t invent this, but we solved new problems with it.
Tristan Handy: I remember creating my first Docker container around 2015. I expected a slow boot-up like a VM, but it was instantaneous. Where is the OS in that setup?
Solomon Hykes: Great question. Docker relies on Linux. When you're on a Mac, it runs Linux behind the scenes—today via virtualization. Back then, we used lots of early, rough tools and kernel patches to make Linux containers work. Docker put all the pieces together in a coherent way.
Tristan Handy: So containerization wasn’t new, but Docker made it accessible?
Solomon Hykes:
Exactly. The Linux kernel had features like namespaces and cgroups—building blocks for containers. But they weren’t user-friendly. We made a developer-centric abstraction on top of those tools.
And Linux provided a massive compatibility layer. Unlike Java, which required writing your app in Java, Docker containers could wrap apps written in any language, as long as they ran on Linux.
Tristan Handy: So Docker is like infrastructure as code—a primitive that enables the whole concept?
Solomon Hykes: Yes! And because we wanted ubiquity, we avoided pushing too many opinions. We let developers build on top of it in many different ways. That’s what helped Docker become a de facto standard.
Tristan Handy: How fragmented is the Linux world under the hood? Did you have to do much abstraction work?
Solomon Hykes: We were lucky. The Linux kernel is extremely stable and consistent. But everything above it—distros, package managers, tooling—was chaotic. That chaos created the opportunity for Docker to provide a consistent experience.
Tristan Handy: Were there any drawbacks? Like “Docker sprawl” the way VMware saw VM sprawl?
Solomon Hykes: Definitely. With power comes chaos. Teams would run dozens of Docker containers, each configured differently. Docker doesn’t enforce opinions—by design.
Tristan Handy: And what happened when you left Docker in 2018?
Solomon Hykes: I took time off, became a full-time dad. But I also realized how many unsolved problems remained. Especially around CI/CD pipelines and software delivery—what we now call the software factory.
That led me to start Dagger.
Tristan Handy: So Dagger is like “containers for pipelines”?
Solomon Hykes: Yes. Just as Docker standardized app deployment, Dagger aims to standardize and containerize software delivery. CI/CD pipelines today are often duct-taped together with YAML and bash scripts. We’re bringing consistency and modularity to that space.
Tristan Handy: Will there be a “Daggerfile” like there’s a Dockerfile?
Solomon Hykes: Sort of. But this time, we’re opinionated. Dagger is narrowly focused on CI/CD. That lets us provide APIs, SDKs, and a deeper abstraction stack. We give platform engineers a DAG-based system to define repeatable, containerized steps.
Tristan Handy: And what’s the role of AI and agents in all this?
Solomon Hykes: Great question. We didn’t plan for it, but our community showed us the way. People started building AI agents that run in Dagger pipelines—automating things like writing tests, submitting PRs, and optimizing builds.
That blew our minds. Agents blur the line between development and delivery. They need programmable environments. Dagger is becoming an ideal platform for that.
Chapters
01:30 – Early Days: From France to dotCloud
Solomon shares how his early programming experience and startup journey led to the creation of dotCloud.
04:00 – The PaaS Struggle and Birth of Docker
The team pivots from platform-as-a-service to focusing on the container engine itself—what would become Docker.
07:00 – What Is a Container, Really?
Solomon explains containerization vs. virtualization in plain terms and why it changed the game for developers.
11:00 – The Developer Experience That Won the World
The magic of fast, lightweight Docker containers—and how that first “wow” moment felt.
14:00 – Building a Ubiquitous Standard
Why Docker stayed narrow by design, resisting feature bloat to maximize compatibility.
18:00 – DevOps Before DevOps
How Docker avoided language tribalism and achieved mass developer adoption by choosing Go and CLI-first tooling.
21:00 – Complexity and Container Sprawl
Docker made infrastructure easy—but created new operational challenges at scale.
24:30 – Why CI/CD Pipelines Are Still Broken
Solomon outlines the gap Docker never got to fix: modern software delivery remains brittle and ad hoc.
27:00 – Enter Dagger: DevOps for the Modern Age
How Solomon’s new company is treating pipelines as composable software, not brittle scripts.
30:00 – Building an OS for the Software Factory
Dagger helps platform teams manage the complexity of software delivery with reusable, testable components.
33:00 – Agent-Native Workflows: A Surprise Use Case
AI agents begin using Dagger to reason about pipelines, generate code, and submit pull requests autonomously.
37:00 – Reimagining the Dev Loop with AI
Why the boundary between development and CI/CD is collapsing—and how Dagger fits the agent-powered future.
41:00 – Scaling Trust in Delivery
Tristan and Solomon reflect on how developer tooling evolves and what a stable, fast delivery layer enables.
45:00 – Final Thoughts: What’s Next for DevOps
The conversation closes with predictions on intelligent automation, composability, and the future of platform engineering.
Published on: Jun 22, 2025
2025 dbt Launch Showcase
Catch our Showcase launch replay to hear from our executives and product leaders about the latest features landing in dbt.
Set your organization up for success. Read the business case guide to accelerate time to value with dbt.
