Category: Life bytes

A few years ago, I was crossing the street with my 7-year-old son. Traffic was heavy, cars everywhere.

“You know,” I said, “in my time, there weren’t so many cars. Much safer for kids to cross streets.”

He looked up at me with those matter-of-fact eyes kids have and said:

“I know, Dad. You were using horse carriages back then...”

I opened my mouth to protest. Closed it. And started laughing.

That moment stuck with me.

The Pattern That Never Changes

Years later, that conversation echoes every time I hear someone in tech say “the old ways were simpler.” My son was 7. He had no real perception of time. But somehow, with that one line, he captured something I’d forgotten:

Every generation has the same conversation.

And every generation is both right and wrong.

What We Remember vs. What We Forget

The father remembers:

• Fewer cars on the road

• Kids could play in streets

• Quieter neighborhoods

What he forgets:

• Horse shit everywhere

• No traffic lights or safety regulations

• Epidemic outbreaks

• Limited mobility (couldn’t travel far)

• Horses kicked and bit children

In Technology World?

Same truth: every era thinks it’s the most complicated.

Senior Dev: “Code was cleaner before all these frameworks!”

Junior Dev: “You mean when you manually managed memory and wrote your own XML parsers?”

Both are right. Both are wrong.

Fewer frameworks ≠ Better software (We had fewer problems because we solved fewer problems).

Simpler codebases ≠ More stable (We just couldn’t scale to handle today’s challenges).

“The old way” ≠ Actually better (We remember the constraints as simplicity)

Why This Matters for Software

What we’re nostalgic about:

• Monolithic codebases (”everything in one place!”)

• Manual deployments (”we knew exactly what was deployed!”)

• Limited dependencies (”no npm hell!”)

What we’re forgetting:

• Deployment took weeks of manual work

• Single point of failure killed everything

• Can’t scale teams beyond 5-10 developers

• “Works on my machine” was an accepted excuse

• No automated testing or CI/CD

Progress Isn’t About Fewer Problems

It’s about having better problems to solve.

Horse carriages didn’t have traffic jams. But they couldn’t scale to modern city populations.

Monoliths didn’t have distributed tracing complexity. But they couldn’t handle modern user loads or team sizes.

Manual deployments didn’t have CI/CD pipeline failures. But they took months and had zero rollback capability.

Kubernetes isn’t “simple.” But it solves problems that were literally impossible in 2005.

The CEO One-Liner

“Legacy nostalgia mistakes fewer capabilities for fewer problems.”

We don’t have more complexity today because we’re doing it wrong. We have more complexity because we’re solving harder problems.

The Stagecoach Drivers Said the Same Thing

When cars were invented, stagecoach drivers complained:

“These automobiles are dangerous! Too fast! Too complicated! Nobody knows how to maintain them!”.

They were right about the problems. They were wrong about going back.

My Personal Reflection

My son is a teenager now. He probably doesn’t remember that conversation. But I do. Because every time a senior dev tells me “code was cleaner before frameworks”, I hear a 7-year-old’s voice: “You mean with stagecoaches, Dad?”.

Some patterns never change. Even when everything else does.

Cheers!
Miro - The TechMetaphorist

Want More Software Stories?

This Snack is part of the 8bytes! The Software Restaurant newsletter, where complex tech concepts become digestible stories.

Here I serve:
🍕 Full comic episodes (bi-weekly)
🥨 Quick Snacks like this one

No spam. No sales pitches. Just tech stories that even your grandma can understand (and your manager will pay for).

Illustration credits: Comic scenes conceptualized by 8bytes! and rendered by Nano Banana.

Category: 8bytes! The Restaurant

Jack Falcone left 20 minutes ago…

The eggs were perfect, but nobody was there to eat them.

Welcome to Overengineering

We’ve all been Julia. Spending 50 minutes to make “perfect” scrambled eggs when good eggs take 3 minutes. Building elaborate systems for problems we don’t have yet. Optimizing for scale we’ll never reach.

The perfectionist’s curse: We confuse complexity with quality.

What Julia’s Kitchen Teaches Us

Julia used sous vide machine for precise temperature control, digital thermometer, pH meter, $200 copper pan, precision scale (to the gram), truffle oil, gold leaf garnish, multiple timers (millisecond precision!).

Time: 50 minutes
Cost: $47 in ingredients and equipment
Customer satisfaction: 0 (they left)

What was actually needed - Regular pan. Butter. Salt. Pepper. Full stop.

Time: 3 minutes
Cost: $2
Customer satisfaction: High (if they’d stayed)

The Software Development Reflection?

Overengineered:

• Distributed event-sourcing system

• CQRS pattern

• Kafka for event streaming

• Cassandra for write scaling

• Redis for caching

• Elasticsearch for queries

• Custom consistency resolver

Team size needed: 15+ engineers
Learning curve: 6 months
Can handle: Billions of events

Good enough:

• Postgres with good indexes

• Maybe Redis for hot data

• Backups automated

Team size needed: 2 engineers
Learning curve: 1 week
Can handle: Millions of records (which is all you need)

Why We Overengineer

Perfectionism Feels Like Professionalism

“If I don’t use the latest tech, am I even a real engineer?”

Yes. You are. Building things that work makes you a real engineer. Using every tool in the toolbox makes you exhausted.

Resume-Driven Development

“I need Kubernetes experience for my next job!”

Great. But your current startup with 100 users doesn’t need Kubernetes. Your resume will survive without it. Your startup might not survive with it.

Fear of Criticism

“Someone might say my solution is ‘too simple.’”

You know what’s worse than “too simple”?, “Doesn’t work” and “Never shipped.”

Solving Tomorrow’s Problems Today

“We might need to scale to 1 million users!”

You have 47 users. Build for 47 users. When you have 47,000 users, then optimize (Spoiler: If you overengineer now, you’ll never get to 47,000.)

The Illusion of Control

Complex systems feel controllable because we built them. Simple systems feel risky because we didn’t build everything. This is backwards. Complex systems have more failure modes. Simple systems are easier to fix when they break.

When Perfection Actually Matters

Don’t get me wrong - sometimes precision is critical.

Build for perfection when:

• Medical device software (lives at stake)

• Financial transactions (money at stake)

• Aviation systems (lives at stake)

• Nuclear reactor controls (many lives at stake)

• Security infrastructure (data at stake)

Don’t build for perfection when:

• Internal tool for 5 people

• MVP testing product-market fit

• Side project you’re learning from

• Scrambled eggs for lunch

• 90% of software projects

The Real Kicker

Simple solutions are often better - faster to build, easier to maintain, lower probability to fail, actually get used as customers gets real value fast. Don’t believe me?

Julia’s 3-minute scrambled eggs? Customer loved them.
Julia’s 50-minute perfect eggs? Customer never saw them.

The Cost of Overengineering

Four words: Time. Money. Opportunity. Simplicity.

It takes 50 minutes to finish a task instead of 3 minutes. Market reach for new functionalities take weeks or months instead of days. And all this requires a lot more money for engineers, tools, infrastructure and licensing costs, money that may never repay. Customers leaving before seeing the new feature, always behind faster shipping competitors (“But! Their services are awful, we are going to make it a lot better, right?!”). Losing market share. Team burned out. People lost… Onboarding of new team members becomes very hard because of the steep learning curve.

My Confession

I’ve been Julia. Many times. (even now when I try to simplify this article for the 10th time 😳). So always try to think whether simple scramble eggs would fill the tummy. Ask yourself:

“Will simple work?” (Probably yes)
“Do we have this problem NOW?” (Probably no)
“Can we buy a solution?” (Probably yes, and it’s cheaper)
“Will the customer care?” (Probably no)
“Will this help us ship faster?” (Definitely no)

And most of the time it seems perfect can wait.

Cheers!
Miro - The TechMetaphorist

P.S. Julia eventually learned. Now she makes scrambled eggs in 3 minutes. They’re good enough. Customers love them. And Jack came back.

P.P.S. She still has the sous vide machine. But it’s in the storage. Just in case she ever needs truly optimal protein structure. (She won’t.)

Want More Software Stories?

This Snack is part of the 8bytes! The Software Restaurant newsletter, where complex tech concepts become digestible stories.

Here I serve:
🍕 Full comic episodes (bi-weekly)
🥨 Quick Snacks like this one

Tech stories that even your grandma can understand (and your manager will pay for).

Illustration credits: Comic scenes conceptualized by 8bytes! and rendered by Nano Banana.

Category: Workplace Humor

The Moment of Realization

We’ve all been there. That precise moment when you discover you’ve committed to something without checking if you have what you need to complete it. The empty toilet paper roll is just the most... immediate example.

The Pattern Everywhere

In the bathroom: You need toilet paper. You don’t have toilet paper. You’re committed.

In software: You need API access. You don’t have API keys. Sprint started yesterday.

In business: You need budget for Q2. Finance says no. Team already hired.

In architecture: You need database migration path. No one documented the schema. Deployment is Friday.

The Universal Law - “Don’t start what you can’t finish!”

Sounds obvious. Yet we do it constantly:

• Starting sprints without clarifying requirements

• Beginning deployments without testing environments

• Launching features without capacity planning

• Hiring teams without runway for year 2

• Building products without market validation

• Committing to deadlines without resource allocation

And yes, sitting down without checking the toilet paper situation.

The Lack of Toilet Paper in Tech

Starting a migration without:

• Rollback plan

• Database backup

• Downtime window

• Team on standby

Starting a feature without:

• API documentation

• Server capacity

• Testing environment

• User research

Starting a project without:

• Clear requirements

• Resource allocation

• Success metrics

• Exit strategy

The CEO One-Liner

“Prerequisites > Promises”

You can promise anything. But without the prerequisites in place, you’re just... well, you’re in the bathroom without toilet paper.

The Emergency Workarounds

When you’re already committed and discover missing resources:

Bad options:

• Improvise poorly (tissues, napkins, newspapers)

• Panic (doesn’t help)

• Blame others (still stuck)

• Give up (really?)

Better option:

• Pause and acquire resources (even if embarrassing)

Best option:

• Check BEFORE you start (boring but effective)

The Checklist Culture

Google’s Site Reliability Engineering uses checklists for everything. Pilots use pre-flight checklists. Surgeons use pre-surgery checklists. Maybe we should use pre-bathroom checklists? 🤔

Pre-Deployment Checklist:

• All dependencies available?

• Rollback plan ready?

• Team on standby?

• Monitoring in place?

• Toilet paper checked?

Okay, maybe not that last one. But you get the idea.

My Reflection

I learned this lesson the hard way. Multiple times.

• Started a refactoring project without buy-in from the team (failed)

• Committed to a deadline without checking team capacity (disaster)

• Began a migration without a rollback plan (nightmare)

And yes, I’ve also been in that bathroom situation.

The empty roll is a perfect metaphor because:

1. It’s universal (everyone relates)

2. It’s immediate (no time to fix)

3. It’s avoidable (just check first)

4. It’s embarrassing (which makes us remember)

The Takeaway

Don’t start what you can’t finish.

It’s that simple - check your resources, then commit! Not the other way around.

Cheers!
Miro - The Tech Metaphorist

Want More Software Stories?

This Snack is part of the 8bytes! The Software Restaurant newsletter, where complex tech concepts become digestible stories.

Here I serve:
🍕 Full comic episodes (bi-weekly)
🥨 Quick Snacks like this one

Tech stories that even your grandma can understand (and your manager will pay for).

TEASER:
Upocming toilet “issue” in the Restaurant’s E05 “Stop the World”. Drops on Feb 20! Subsribe now to not miss it!
Meanwhile episode E04 “The Pineapple Glitch” (deep-dive into the HEAP) is coming on Thursday, Feb 6.

Illustration credits: Comic scenes conceptualized by 8bytes! and rendered by Nano Banana.

Category: Workplace Humor

What's your restaurant's DoR (Definition-of-Ready) for taking orders?

Here is my non-exhaustive checklist:

✅ User story is clear - can the team explain it in their own words? (or draw a comic about it)
✅ Acceptance criteria defined - what does “done” look like?
✅ Dependencies identified - do we need other teams/systems?
✅ Technical approach discussed - no surprises mid-sprint
✅ Estimated by the team - not by management alone
✅ Test strategy agreed - how will we verify it works?
✅ Design/mockups ready - if UI is involved
✅ Data requirements known - what goes in, what comes out?

What happens without DoR? You pull a “big fridge” from the backlog... then discover it won’t fit through the door, needs special power, and the customer actually wanted a freezer.

The real cost: Not the time spent moving the fridge. It’s the context switching, the blocked sprint, and the team’s trust in the backlog evaporating.

What's missing from this list? What's your team's biggest DoR fail?

Leave a comment

🥨 What Are Snacks?

Snacks are my comic “shorts” - bite-sized, visual stories where tech meets real life.

• Tech Tales: Daily struggles of a software architect.

• Workplace Humor: The funny reality of the corporate world.

• Life Bytes: Personal “snacks” from hilarious moments with my kids.

A bit of tech, a lot of humor - perfect for reading between two meetings.

Illustration credits: Comic scenes conceptualized by 8bytes! and rendered by Nano Banana.

Category: 8bytes! The Restaurant

Caching seems the magic pill for fast service, right?!

But as Phil Karlton said “There are only two hard things in Computer Science: cache invalidation and naming things.”

Our Chef Julia learned the Phil Karlton lesson the hard way.

Because caching is all about dealing with assumptions - after how long your precooked lasagna becomes trash!

🍽️ Want the Full Course?

Read the full story on the 3rd episode of my 8bytes! comic series.

We’ll dive into Cache Hit, Cache Miss and Stale Data. You will learn software caching strategies and how to explain them to your CEO… or to your gradma.

👉 s01e03: When the Cache Goes Stale (‘The Meatless Miss’)

🥨 What Are Snacks?

Snacks are my comic “shorts” - bite-sized, visual stories where tech meets real life.

• Tech Tales: Daily struggles of a software architect.

• Workplace Humor: The funny reality of the corporate world.

• Life Bytes: Personal “snacks” from hilarious moments with my kids.

A bit of tech, a lot of humor - perfect for reading between two meetings.

Illustration credits: Comic scenes conceptualized by 8bytes! and rendered by Nano Banana.

Category: 8bytes! The Restaurant

Dispatching a Parallel Task can become scary. Combined with a bad Base Case for a loop or recurion, it becomes a nightmare. One moment you are optimizing for speed, the next you’ve paralyzed your entire system.

One missing exit condition. A mountain of lasagna layers. One massive system crash.

🍽️ Want the Full Course?

Read the full story on the first episode of my 8bytes! comic series.

We’ll dive into Stack Frames and Iteration vs. Recursion, and you will learn how to explain them to your CEO… or to your gradma.

👉 s01e01: When the Execution Stack Hits the Ceiling (‘A Lasagna Ricorsiva’)

🥨 What Are Snacks?

Snacks are my comic “shorts” - bite-sized, visual stories where tech meets real life.

• Tech Tales: Daily struggles of a software architect.

• Workplace Humor: The funny reality of the corporate world.

• Life Bytes: Personal “snacks” from hilarious moments with my kids.

A bit of tech, a lot of humor - perfect for reading between two meetings.

Illustration credits: Comic scenes conceptualized by 8bytes! and rendered by Nano Banana.

Category: 8bytes! Alternate Universe

At the beginning of 2026, we were called into the office because the management board was visiting to greet us. As they walked in, this funny thought popped into my mind…

In Bulgaria (a country in the European Union where I was born), we have a millennia-old tradition called Survakane. On the 1st of January, children ‘survak’ the elders for health and wealth, receiving small treats or pocket money in return, similar to the ‘trick or treat’ spirit of Halloween.

The ‘survachka’ is made from cornel twigs (dogwood), decorated with colorful woolen threads, popcorn, dried fruits, and small coins. This specific wood is chosen because it is the toughest and the first to bud in winter, symbolizing endurance and vitality. As the children gently tap your back, they recite traditional poems to wish you a fruitful and prosperous year ahead! (Ref: https://en.wikipedia.org/wiki/Survakane)

🥨 What Are Snacks?

Snacks are my comic “shorts” - bite-sized, visual stories where tech meets real life.

• Tech Tales: Daily struggles of a software architect.

• Workplace Humor: The funny reality of the corporate world.

• Life Bytes: Personal “snacks” from hilarious moments with my kids.

A bit of tech, a lot of humor - perfect for reading between two meetings.

Illustration credits: Comic scenes conceptualized by 8bytes! and rendered by Nano Banana.

Category: 8bytes! Alternate Universe

Even today, in Enterprise world we still struggle with getting rid of legacy SOAP services. I knew that its gonna be challenging to replace all SOAP in a heavy Bancassurance company. And three years later, some SOAP service still pops up from here and there…

Some time ago, I asked GEMINI when was SOAP invented… 😅 And damn! That thing’s ANCIENT! And it emerged ACCIDENTALLY! Now it all make sense…

It reminds me of that classic scene in Raiders of the Lost Ark. Indiana Jones was carefully trying to swap a golden idol for a bag of sand, knowing that if the weight is even slightly off, the whole temple collapses.

Cheer up, Enterprise Architects! It’s not that bad, you are Indiana Jones alike!

🥨 What Are Snacks?

Snacks are my comic “shorts” - bite-sized, visual stories where tech meets real life.

• Tech Tales: Daily struggles of a software architect.

• Workplace Humor: The funny reality of the corporate world.

• Life Bytes: Personal “snacks” from hilarious moments with my kids.

A bit of tech, a lot of humor - perfect for reading between two meetings.

Illustration credits: Comic scenes conceptualized by 8bytes! and rendered by Nano Banana.