I Run 85 Docker Containers as a Solo Founder. Here's What That Actually Means.

# I Run 85 Docker Containers as a Solo Founder. Here's What That Actually Means.

Frederik von der Heyden runs 85 Docker containers in production. Alone. No DevOps team. No SRE on call at 3am. Just bare metal, Bash, and a set of 176 guard rules he calls his system's immune system.

This is not a stunt. It's what the one-person-unicorn model looks like when it hits infrastructure complexity at scale.

What 85 containers actually means

Von der Heyden runs single-tenant PostgreSQL per customer — a Supabase stack for each client, spun up on bare metal servers. That's not the cheapest architecture. It's also not the laziest. Single-tenant means every new customer requires new provisioned infrastructure. It means 85 containers isn't a vanity number — it's a direct measure of paying customers and active workloads.

The trade-off he's making: stronger data isolation, easier per-customer backups and migrations, no noisy-neighbor problems. The cost: every operational task multiplies by the number of tenants.

At 85 containers, you cannot manage this manually. You cannot check in on each one. You cannot notice when something silently degrades. This is where most solo founders either hire ops people, use a managed platform and eat the margin, or build automation that does the watching for them.

Von der Heyden chose the third path.

The Bash layer that replaces a DevOps team

The core of the system is a set of Bash scripts handling what an ops team would otherwise own: health checks, restarts, log monitoring, alerting. Not glamorous. Not an AI feature. Just reliable automation that runs on a schedule and handles failure states before they become incidents.

This is a pattern worth naming: infrastructure automation as the first hire you never make. Before you need a DevOps engineer, you need scripts that encode what a DevOps engineer would do at 2am. The scripts don't get tired. They don't miss alerts because they were in a meeting.

For solo founders, the Bash layer is load-bearing. It's the difference between a business that can operate while you sleep and one that requires your constant attention to stay alive.

176 guard rules: what an immune system looks like in code

The more interesting part of von der Heyden's stack is the 176 guard rules he's built around his AI agents.

He runs Claude-based agents in production — doing real work, taking real actions. The guard rules are constraints, validations, and decision boundaries that catch agent mistakes before they cause damage. When an agent makes an error, the learning gets captured and encoded as a new rule. The system gets harder to break over time.

This is how you run AI agents in production without a safety team. You don't prevent all mistakes upfront — you build a system that learns from mistakes and adds guardrails retroactively. 176 rules didn't exist on day one. They accumulated from real failures.

The architecture is significant. Most AI agent deployments treat guardrails as a launch checklist. Von der Heyden treats them as a living document that grows with the system's failure history. That's a fundamentally different approach — and one that scales without adding headcount.

The honest limitations he names

Von der Heyden is direct about what doesn't scale cleanly in this model. Single-tenant architecture means provisioning new infrastructure per customer. At 85 customers, Bash handles it. At 850, the provisioning logic needs to be more robust. The system works until it doesn't, and he knows where the ceiling is.

This kind of self-awareness is underrated in solo founder writing. The temptation is to present the stack as universally applicable. He doesn't. He says: if you're running AI agents in production, you need something like this. He doesn't say it's easy to build or that it works at any scale without modification.

For founders evaluating their own infrastructure, this is the useful framing: what's the ceiling of your current automation layer, and have you hit it yet?

What this means for the revenue-per-employee metric

Von der Heyden's setup is a live example of what revenue per employee looks like when AI and automation replace traditional team functions. A standard SaaS company at 85 customers with a single-tenant architecture would have at minimum: a DevOps engineer, a DBA, and probably an on-call rotation. That's $400K–$600K in fully-loaded annual cost before you've written a line of product code.

Running this on Bash and guard rules doesn't mean zero operational cost. It means the operational cost is time — von der Heyden's time to build and maintain the automation — rather than headcount. When the automation is working, the marginal cost of adding a new customer is the cost of spinning up a container, not the cost of another salary.

That's the bet the one-person-unicorn model makes: front-load the engineering investment in automation, compress the ongoing cost structure, run at a revenue-per-employee ratio that a traditionally staffed company can't match.

What to steal from this stack

If you're a solo founder running production systems, three things from von der Heyden's approach are worth taking seriously:

Build the Bash before you need it. Health checks and restart scripts feel unnecessary until the first time you wake up to a dead container. Write the automation when things are calm, not when they're on fire.

Treat guard rules as a changelog, not a checklist. Every AI agent mistake is a rule that doesn't exist yet. Build the capture mechanism first — a simple log of failures and the constraint that would have prevented each one. The rules accumulate naturally.

Know your ceiling. Single-tenant at 85 customers is manageable. At 500, it's a different problem. Design for your next order of magnitude, not your current one.

The broader point: running 85 Docker containers as a solo founder isn't a flex about technical heroics. It's a demonstration that infrastructure complexity is no longer the forcing function for hiring. The constraint has shifted. Automation handles the operational load. The solo founder's job is to build and maintain the automation layer — which is a fundamentally different skill than managing an ops team, and a much cheaper one.

This is what AI-native companies are already doing in 2026: collapsing the traditional org chart by replacing team functions with systems. Von der Heyden's stack is an unusually transparent look at what that actually requires at the infrastructure layer.

It requires Bash. It requires 176 rules. It requires knowing where your system will break before it does.

None of that is simple. All of it is learnable.

---

Is your company eligible? Submit to the leaderboard → onepersonunicorn.co/submit