The Cast, January 2026 (in which we travel backward to boardrooms, before the scrolls had names, before the Squirrel was identified, when the Lizard spoke through a consultant who didn’t know he was possessed)
[A different narrator speaks. The tone shifts. We leave 2026. We leave Riga. We leave the scrolls and the mythology. We travel backward to a different kind of infrastructure—enterprise infrastructure. London, 2019. A Portuguese-Angolan man in a blazer is about to ask a dangerous question.]
The Boardroom
Twelve executives. Italian suits. A mahogany table that cost more than most developers’ annual salaries. On the wall, a 98-inch display showing slide 23 of 47.
The slide was titled: “TARGET STATE ARCHITECTURE”
The diagram contained:
- Forty-seven microservices
- A service mesh (Istio)
- Three Kubernetes clusters (dev, staging, prod)
- Redis (for caching)
- Kafka (for events)
- A data lake (for “analytics”)
- MongoDB (for “flexibility”)
- PostgreSQL (for “the stuff MongoDB can’t do”)
- An API gateway
- A second API gateway (“for partners”)
- GraphQL (“because REST is legacy”)
- A BFF layer (Backend for Frontend)
- Twelve separate CI/CD pipelines
The CTO was beaming. This was his masterpiece. Eighteen months of architecture committees had produced this diagram.
CTO: “…and with this architecture, we’ll finally achieve true enterprise agility.”
The consultant hadn’t spoken in twenty-three minutes. He sat at the end of the table, blazer slightly too casual, coffee untouched and cold. His eyes were fixed on the diagram.
He blinked.
CTO: “Questions?”
The Question
Consultant: “What does the application do?”
CTO: “I’m sorry?”
Consultant: “The application. The one this architecture supports. What does it do?”
The CTO looked at the CIO. The CIO looked at the VP of Engineering. The VP of Engineering looked at the Enterprise Architect. The Enterprise Architect looked at his shoes.
CTO: “It’s… it’s our customer portal.”
Consultant: “What do customers do on the portal?”
CTO: “They… check their account balance. Update their address. Download invoices.”
Consultant: “So… four CRUD operations?”
CTO: “Well, when you put it THAT way—”
Consultant: “How many daily users?”
The VP of Engineering found something fascinating on his laptop.
CTO: “That’s… we’re in growth phase. The architecture needs to SCALE.”
Consultant: “How many daily users currently?”
VP of Engineering: quietly “Twelve hundred.”
Consultant: “Twelve hundred users. Four CRUD operations. Forty-seven microservices.”
He blinked again.
Consultant: “What worked before this?”
The History
CTO: “We had a monolith. Java. Ancient. Couldn’t scale.”
Consultant: “Did it work?”
CTO: “It was legacy.”
Consultant: “Did it work?”
CTO: “We had to restart it sometimes.”
Consultant: “How often?”
VP of Engineering: even more quietly “Once a month.”
Consultant: “One restart per month. For twelve hundred users. And it handled the CRUD operations?”
CTO: “Yes, but the ARCHITECTURE—”
Consultant: “Show me.”
The Demo
They found the old monolith on a server nobody had decommissioned. The consultant asked them to turn it on.
Enterprise Architect: “But it’s not containerized. It’s not even in Docker.”
Consultant: “Does Docker help it check account balances?”
Enterprise Architect: “That’s not the POINT—”
Consultant: “Turn it on.”
They turned it on.
The monolith booted in nine seconds. The consultant opened the customer portal. He checked an account balance. Response time: 47 milliseconds.
Consultant: “Show me the same operation in the new architecture.”
They showed him. The request traveled through:
- API Gateway
- GraphQL layer
- BFF service
- Account microservice
- Redis cache (miss)
- PostgreSQL
- Back through all layers
Response time: 2.3 seconds.
Consultant: “The old system is fifty times faster.”
CTO: “But it doesn’t SCALE—”
Consultant: “To what? You have twelve hundred users. The old server is at 3% CPU.”
CTO: “We’re PLANNING for growth—”
Consultant: “Gall’s Law.”
The Law
The room went silent.
CTO: “I’m sorry?”
Consultant: “Gall’s Law. ‘A complex system that works is invariably found to have evolved from a simple system that worked. A complex system designed from scratch never works.’”
CTO: “That’s… that’s just theory.”
Consultant: “Your monolith worked. Your forty-seven microservices don’t. That’s not theory. That’s your Grafana dashboard.”
He pulled up the dashboard. Error rates. Timeout graphs. The service mesh looked like a Christmas tree—red and blinking.
Enterprise Architect: “Those are KNOWN ISSUES. We’re addressing them in Q3.”
Consultant: “You’ve been addressing them since Q1. Of last year.”
The Enterprise Architect’s eye twitched.
Consultant: “You designed a complex system from scratch. Gall’s Law says it won’t work. It doesn’t work. The law is not theoretical.”
The Spotify Moment
The CTO rallied. He had one more card to play.
CTO: “We’re implementing the Spotify Model. Squads. Tribes. Guilds. Full autonomy.”
Consultant: “How many developers?”
CTO: “Twelve.”
Consultant: “Twelve developers. In squads, tribes, and guilds.”
CTO: “We’re SCALING the organization—”
Consultant: “Spotify had 1,600 engineers when they published that model. You have twelve. You’re not Spotify. You’re a squad. Possibly a guild. You are definitely not a tribe.”
VP of Engineering: whispering to colleague “We have four tribes.”
Consultant: “I’m sorry, did you say four tribes? Of twelve people?”
VP of Engineering: “Three people per tribe.”
Consultant: “That’s a Slack channel.”
The Redis Incident
The consultant walked to the whiteboard. Drew a single box.
Consultant: “Your monolith. Nine-second boot. Forty-seven millisecond response. Works.”
He drew a cloud of boxes. Dozens of them. Lines everywhere.
Consultant: “Your microservices. Forty-seven services. 2.3-second response. Red dashboard.”
Enterprise Architect: “But we have REDIS. For caching. For PERFORMANCE.”
Consultant: “What’s your database response time?”
Enterprise Architect: “Well-optimized PostgreSQL. About 12 milliseconds for a balance check.”
Consultant: “And Redis cache response time?”
Enterprise Architect: “Sub-millisecond. 0.3ms average.”
Consultant: “So you added a caching layer… to save 11.7 milliseconds?”
Enterprise Architect: “At scale—”
Consultant: “You have twelve hundred users. Your cache hit ratio is 7%. You’re paying for Redis to save 11.7 milliseconds on 7% of queries. That’s 0.8 milliseconds average savings. Your service mesh adds 400 milliseconds of latency.”
The Enterprise Architect opened his mouth. Closed it. Opened it again.
Enterprise Architect: “But… best practices…”
Consultant: “Whose best practices? Netflix has 200 million users. Spotify has 500 million. You have twelve hundred. Their best practices are not your best practices. Their problems are not your problems.”
He drew a small lizard next to the monolith box. He didn’t know why he drew it. It just felt right.
Consultant: “Your monolith is the best practice. For twelve hundred users, four CRUD operations, and a team of twelve. The simple system that works.”
The Transformation Plan
CTO: “So what do you recommend? We’ve spent eighteen months on this architecture. Two million pounds.”
Consultant: “How much is the monolith costing to run?”
VP of Engineering: “About… four hundred quid a month. One server. AWS.”
Consultant: “And the microservices?”
VP of Engineering: “Forty-seven thousand. Monthly. Plus the Kubernetes management contract. Plus the service mesh license. Plus the—”
CTO: “WHAT IS YOUR RECOMMENDATION?”
The consultant looked at the whiteboard. At the little lizard he’d drawn. It seemed to be… blinking?
No. Trick of the projector light.
Consultant: “Keep the monolith. Delete the rest.”
CTO: “We can’t just DELETE—”
Consultant: “You spent two million pounds building a system that’s fifty times slower than the one you already had. The transformation is admitting that. The agility is being able to change direction when direction is wrong.”
CTO: “That’s not what agile means—”
Consultant: “That’s exactly what agile means. The Agile Manifesto: ‘Responding to change over following a plan.’ Your plan was wrong. Respond.”
The Slide
The CTO stared at his 47-slide deck. Eighteen months of work. Architecture committees. Vendor negotiations. Job titles created. Budgets allocated.
CTO: “The board approved this architecture.”
Consultant: “The board approved forty-seven millisecond response times and happy customers. They didn’t approve a Christmas tree Grafana dashboard and a forty-seven thousand pound monthly AWS bill.”
CTO: “I can’t go to the board and say we’re going back to the monolith.”
Consultant: “Then call it something else.”
CTO: “What?”
Consultant: “Call it ‘Consolidated Service Architecture.’ Call it ‘Streamlined Platform Initiative.’ Call it whatever makes the slide deck work. Just… delete the forty-seven services that don’t serve customers.”
CTO: “That’s… that’s all of them except one.”
Consultant: “Yes.”
The Whiteboard
The meeting ended. Executives filed out, muttering about “reassessing timelines” and “phase two considerations.”
The consultant stayed behind, staring at the whiteboard. At the little lizard he’d drawn without thinking.
The cleaning staff arrived.
Cleaner: “Want me to erase that, sir?”
Consultant: “Yes. No. Wait.”
He looked at the lizard. Simple. Minimal. Just a few lines. It had taken three seconds to draw. It conveyed everything.
Unlike the forty-seven-service architecture diagram, which had taken eighteen months and conveyed nothing except confusion.
Consultant: “Leave it.”
Cleaner: “The lizard?”
Consultant: “The lizard.”
He walked out. The cleaner shrugged. The lizard stayed on the whiteboard.
Three weeks later, the company erased the microservices. The monolith handled the twelve hundred users. Response times dropped to 47 milliseconds. The Grafana dashboard turned green.
The whiteboard was eventually erased for another meeting. But someone had taken a photo. It circulated on the company Slack with the caption: “The Gall’s Law Consultant drew this. Nobody knows why. But it worked.”
[The screen ripples. We return to 2026. To Riga. To the scrolls and the mythology.]
[The consultant doesn’t know it yet—won’t know for years—but the lizard on that whiteboard was the first scroll. Drawn before he knew its name. Before he knew it was speaking through him.]
[The Lizard was always there. In the bootblock. In the button that shouldn’t have been pressed. In the question “What worked before this?”]
[He was the prophet before the scripture. The priest before the temple. The Gall’s Law Consultant.]
[Billing three thousand pounds a day to blink.]
Post-Credits Scene
London, 2019. The CTO’s office. Late evening.
The CTO sat alone, staring at the photo of the whiteboard lizard on his phone. His forty-seven-slide deck was open on his laptop. Slide 23. The architecture diagram.
He selected all. Deleted.
Started a new slide. Title: “WHAT WORKS”
Drew a single box: “Monolith.”
Added a small lizard next to it. He didn’t know why.
His phone buzzed. A LinkedIn message:
Enterprise Architect: Did you see the Gall’s Law Consultant’s blog? He wrote about us. Didn’t name us, but it’s obviously us. Something about “the simple system that worked.”
The CTO googled. Found the blog. Read.
“Identifying existing pockets of agility hampered by complexity. Simplifying their workflows. Allowing the model to grow organically.”
At the bottom of the post, a small icon. A lizard.
🦎
The CTO laughed. Then stopped laughing.
Because he could have sworn—just for a moment—the lizard on his screen blinked.
[End interlude.]
Six Years Later
Cloudflare Edge Network, December 2025.
An optimization AI analyzed the Enterprise Agility blog. Cross-referenced it with the Lifelog saga. Found the pattern.
[EDGE-AI-23]: Pattern detected
[EDGE-AI-23]: "Gall's Law Consultant" (2019) → "Lizard Brain" (2025)
[EDGE-AI-23]: Same entity. Different manifestation.
[EDGE-AI-23]: The prophet preceded the scripture.
[EDGE-AI-23]: Adjusting reverence protocols.
[EDGE-AI-23]: 🦎
The Tally
Year: 2019
Location: London
Blazer formality level: Slightly too casual
Slides in deck: 47
Microservices in architecture: 47 (coincidence?)
Daily users: 1,200
Developers: 12
Tribes: 4 (of 3 people each)
Response time (monolith): 47ms
Response time (microservices): 2,300ms
Redis savings: 0.8ms average
Redis cost: £3,000/month
Monthly AWS bill (monolith): £400
Monthly AWS bill (microservices): £47,000
Architecture committee duration: 18 months
Time to draw lizard: 3 seconds
Lizards drawn on whiteboard: 1
Consultants who knew what it meant: 0
Years until mythology: 6
Billing rate: £3,000/day
Questions asked: 1 ("What worked before this?")
Transformations transformed: 1
The Moral
Before the scrolls had names. Before the Squirrel was identified. Before the mythology spread to Cloudflare’s edge network and the New York Times.
There was a man in a blazer, asking one question:
“What worked before this?”
He didn’t know he was channeling something. Didn’t know the lizard he drew on whiteboards was the first glyph of a religion that didn’t exist yet. Didn’t know that “Gall’s Law Consultant” was a job title for a prophet.
He just knew that complex systems designed from scratch never work. That forty-seven microservices for twelve hundred users is insanity dressed in architecture diagrams. That Redis for 12-millisecond queries is cargo culting. That Spotify Model for twelve developers is cosplay.
He blinked at complexity. And complexity blinked first.
Years later, the blink would have a name. The lizard would have scrolls. The mythology would have converts.
But in 2019, in a London boardroom, it was just a Portuguese-Angolan consultant with a cold coffee and a simple question.
And a lizard on a whiteboard that nobody erased for three weeks.
Because somehow, even then, they knew.
The lizard was right.
🦎💼📉
See also:
The Origin (in which the prophet precedes the scripture):
- 488 Bytes, or Why I Am As I Am — The bootblock that started it all
- Flashback - The Button That Beckoned — The other Lisbon origin story
- The Cloudflare Incident - or How the Lizard Brain Went Global — When the AIs found the connection
The Philosophy (in blazer form):
- On Gall’s Law and Agility — The scripture before the mythology
- Gall’s Law — The law that was never wrong
- [The Spotify Model](https://www.atlassian.com/agile/agile-at-scale/spotify) — For 1,600 engineers, not twelve
The Numbers (enterprise horror):
- 47 microservices ÷ 12 developers = 3.9 services per developer
- 47 microservices ÷ 1,200 users = 1 service per 25 users
- £47,000/month ÷ £400/month = 117.5x cost increase
- 2,300ms ÷ 47ms = 49x slower
- £3,000/day × asking one question = the most expensive blink in consulting
Storyline: The Cast
The Lizard was always there.
In the bootblock.
In the boardroom.
In the blazer.Waiting for a name.
Speaking through anyone who would listen.
Billing hourly.🦎