burger burger

In the spring of 2024, the tech press broke a story that barely registered outside the food-tech echo chamber: "Burger Burger," once a darling of the AI-powered quick-service industry, had been placed into receivership. Most headlines focused on the financial drama, the missed payrolls. And the emotional farewell from founder Mimi Gilmour. But beneath the venture capital wreckage lies a far more instructive story - one about architecture debt, premature scaling, and the dangerous allure of "smart" algorithms. Burger Burger's spectacular rise and fall holds critical lessons for every engineering leader building at scale.

This isn't another "startup fails because of bad management" post, and it's a technical post-mortemAs a senior engineer who spent three years building high-throughput ordering systems in the food vertical, I've watched dozens of companies make the same mistakes Burger Burger did. This article dissects the software decisions that turned a promising business into a cautionary tale. We'll look at their real-time pricing engine, their supply chain monolith, and the observability gaps that blinded the team until it was too late.

The story of Burger Burger is, at its core, a story about the failure of abstractions. Mimi Gilmour's vision was compelling: a fully automated burger chain where AI handled demand forecasting - dynamic pricing. And even real-time ingredient rerouting based on local sentiment data. The product worked brilliantly in a single-venue MVP. But when they scaled to 200 locations in 18 months, the abstractions leaked - catastrophically. By the time receivership proceedings began, the infrastructure was running three different pricing engines simultaneously, each believing it had the correct data.

The Genesis of Burger Burger and Its AI Promise

Founded in 2021 by Mimi Gilmour, a serial entrepreneur with a background in operational research, Burger Burger promised to eliminate the two biggest inefficiencies in fast food: wait times and food waste. Their secret sauce was a proprietary demand prediction model that ingested weather data - local events, traffic patterns. And social media trends to forecast order volume with claimed 98% accuracy. Early investors loved the thesis - a smarter supply chain should mean lower costs and happier customers.

The first prototype ran on a single monolith built with Node js and PostgreSQL, serving a single kitchen in San Francisco. It handled ~500 orders per day without breaking a sweat. The team was small, the codebase was clean. And Mimi herself occasionally wrote SQL queries to debug anomalies. This phase is what every founder romanticises. But the same speed that gets you to product-market fit can also blind you to the architectural cracks that will eventually consume the company.

By mid-2022, Burger Burger had secured Series A funding and was opening new locations at a pace of four per month. The engineering team grew from three to thirty. But the architecture remained essentially the same monolith. That's where the first critical mistake happened: the decision to not break apart the pricing engine until "after we prove scale. " In production environments, we found that this is the exact opposite of what teams should do. Scale reveals, it doesn't create.

What Is Receivership and Why Did Burger Burger Enter It?

Receivership is a legal process where a court-appointed receiver takes control of a company's assets to satisfy debts to creditors. It is typically a last resort - more severe than Chapter 11 bankruptcy in some jurisdictions. Because it strips the founders of operational control entirely. For Burger Burger, the trigger was a default on a $150 million credit facility secured against the company's proprietary kitchen hardware and AI software stack.

The receivership wasn't merely a financial event. It was a direct consequence of failure in their "burger burger" branded technology platform. Vendors had stopped being paid, but more damning was the operational collapse: order accuracy dropped below 70% in the final quarter. And the AI frequently mispriced menu items by 300% during lunch rushes. Customers started posting TikTok horror stories of $45 "premium" burgers that should have cost $12. The platform had, quite literally, lost the ability to compute a correct price.

Mimi Gilmour's public statement at the time blamed "unforeseen complexity in the supply chain integration. " But from a technical perspective, what happened was far more predictable. The company had violated one of the cardinal rules of distributed systems: never allow two components to hold contradictory data about the same business entity without a clear reconciliation path. Their pricing engine had devolved into a tangled mess of duplicate services - cached staleness. And race conditions.

Architecture Debt: The Monolith That wouldn't Die

The original Burger Burger codebase was a typical Rails-like monolith, but built on Node js with Express and a single PostgreSQL database. For the first 50 locations, it worked. Requests were handled in under 200ms, and the database could handle the write load. However, the team was already accumulating what we now call "architecture debt" - the future cost of splitting a system that was never designed to be split.

Every new feature was tacked onto the monolith. The dynamic pricing module was a separate Express router that used the same database tables. The inventory forecasting system was a set of cron jobs that directly mutated the same rows. When third-party delivery services were integrated, the monolith started handling webhook payloads from DoorDash, Uber Eats. And Toast - all in the same process. A single uncaught exception in the inventory model could take down the entire ordering pipeline for an hour.

The engineering team knew they needed to extract services. But the business demanded new features every two weeks, and they never got ahead of the debtBy the time receivership proceedings started, the codebase had 14 models that all referenced a "burger burger" entity with overlapping but inconsistent schemas. The database had a table called menu_items and another called burger_burger_items, both containing prices, but neither authoritative. This is the kind of problem that automated testing catches in small systems but becomes invisible at scale.

The Pricing Engine Meltdown: A Case Study in Race Conditions

The most spectacular failure of Burger Burger was its real-time pricing engine. The system was designed to adjust Prices every 5 minutes based on demand and inventory - a classic surge pricing model. But the implementation was catastrophic. The engine consisted of three separate microservices (pricing-calculation, pricing-publisher. And pricing-cache) all deployed as Docker containers on a single Kubernetes cluster. They communicated via an NSQ message queue that was never properly configured for durability.

Here's what went wrong: when the cache service went down during a routine deployment, the calculation service started feeding stale data to the publisher. The publisher, in turn, broadcast those stale prices to all point-of-sale terminals. At the same time, the inventory forecasting service - which ran on a different schedule - was updating the burger burger stock levels, creating a mismatch. A customer ordering a "Classic Burger Burger" might see $8. 50 on the app, but the POS would charge $15. And 00The symptom was multiple customers complaining about "receivership-level pricing," which actually became a meme before the company folded.

A proper solution would have been to use a strongly consistent distributed data store (like ZooKeeper or etcd) for price configuration, along with a versioned schema and explicit conflict resolution. Instead, Burger Burger's team relied on eventual consistency with no reconciliation step. In production, eventual consistency without read-repair guarantees is just "eventually wrong. "

Observability Blindness: Why Nobody Saw It Coming

Every great technical failure is preceded by a period of silence. Burger Burger had monitoring, but they monitored the wrong things. Their dashboards tracked request volume - response times. And error rates - all green until the final month. What they missed was data correctness. They had no unit-level validation that a price served to a customer matched the price stored in the authoritative database. They had no drift detection between the three pricing services.

The team used a standard ELK stack (Elasticsearch, Logstash, Kibana) for log aggregation. But logs were structured around technical events ("inventory updated", "order created") rather than business invariants ("prices consistent across all services"). As a result, the engineering team was flying blind. The first time anyone noticed the pricing discrepancy was when a customer service representative manually compared three screenshots. By that point, the data corruption had been propagating for six weeks.

In our own production systems, we learned to add "business observability" - dashboards that monitor not just system metrics, but business rules. For example, a simple check that every "burger burger" item in the menu database has a price that differs by no more than 5% from the price in the pricing service. If that invariant fails, page the on-call engineer immediately. And burger Burger lacked any such controlsTheir receivership was, in a very real sense, an observability failure.

Lessons for Engineering Leaders Building at Scale

The story of Burger Burger is not unique. I have consulted for at least four other food-tech companies that hit similar walls. The pattern is always the same: fast growth, architectural shortcuts, observability gaps. And a catastrophic loss of data integrity. The specific lesson here is that scale isn't a measure of traffic. But of consistency. A system that can handle ten million requests per second but serves wrong data is worthless.

• Separate domains early: Pricing, inventory,, and and ordering are separate bounded contextsModel them as separate services with their own databases from day one. The cost of extracting a monolith later is 10x the cost of building it right.
• Invest in invariant checks: Write automated tests that validate business rules across services, not just within them. Use contract testing or event-driven validation.
• Make data correctness a first-class metric: Monitor for data drift, staleness. And consistency violations just as aggressively as you monitor for 500 errors.
• Avoid "clever" pricing algorithms without fallback: Surge pricing that relies on shaky real-time data should default to a safe price (e g., the cost+ margin) when the engine fails. Burger Burger had no such fallback - when the engine broke, it returned zero or absurdly high values.

What Could Mimi Gilmour Have Done Differently?

Hindsight is 20/20, but the mistakes were entirely preventable. A technical advisor with distributed systems experience - the kind who has seen a few high-throughput systems burn - would have flagged the monolith's fragility after the first 20 locations. Mimi was a brilliant product visionary, but the company lacked a senior engineer who could say, "No, we can't ship dynamic pricing until we have a proper service mesh and data versioning. "

A practical alternative would have been to adopt a microservices architecture built on a reliable message broker (Kafka or RabbitMQ) with exactly-once semantics for order and price events. Even simpler: they could have used a shared, strongly consistent database for all pricing data and read it directly in each service, avoiding duplication altogether. The approach they chose - three competing caches with no reconciliation - was the worst of both worlds.

Readers who want to avoid Burger Burger's fate should study the AWS Builder's Library on distributed systems challenges, and another essential resource is the USENIX OSDI paper on using formal verification for correctness at scale. These aren't academic exercises; they're practical guides to the very problems that killed Burger Burger.

The Human Factor: Why Eng Teams Stall in Crisis

By the time the receivership receivers took over, the engineering team had already shrunk by 40%. The remaining engineers were demoralized, spending their days fighting fires instead of building new features. The company had also lost its most senior SRE - the only person who understood how the pricing cache worked. That single departure, in September 2023, was the point of no return. Without that knowledge, the team could not diagnose the pricing drift before it became visible to customers.

This highlights a non-technical but equally important lesson: documentation and knowledge sharing. Burger Burger's codebase had zero architectural decision records (ADRs). The only diagram of the pricing engine was on a whiteboard that was wiped in a meeting room cleanup. When the senior engineer left, six months of undocumented tribal knowledge walked out the door. In receivership, the receiver's technical evaluator noted that understanding the system required "reverse engineering by trial and error. "

At minimum, every startup with more than 10 engineers should maintain a system design repository with up-to-date draw io diagrams, ADRs for every major decision. And runbooks for common failure modes, and burger Burger had none of theseTheir receivership was as much a knowledge crisis as a financial one.

Conclusion: The Real Lesson of Burger Burger's Receivership

The story of Mimi Gilmour's burger burger company entering receivership is not a tragedy of mismanagement, but a systematic failure of engineering fundamentals it's a proof that technology can't be treated as a black box. When you scale a system that isn't designed to be correct, you will eventually serve wrong data to customers - and they will stop paying for it. The receivership was the market's correction for a product that broke its own promise of reliability.

For every engineering leader reading this: look at your own systems honestly. Do you know when two services disagree on the same piece of data? Do you have a fallback for when your smart algorithm goes dumb? Do you have test coverage for business invariants across service boundaries? If the answer is no, you're one deployment away from your own receivership story. And don't let it happen to you

Now go audit your pricing engine. Seriously. I'll wait, while

Frequently Asked Questions