After a while, software stops looking like tools.
It starts looking like gravity.
No matter what you build, complexity always sinks downward.
Abstractions float upward.
And if you fight that, the system always wins.
I didn’t plan this model. I just kept noticing the same shape everywhere.
So I stopped naming patterns and started drawing pyramids.
Pyramid: Frameworks Are Just UX for Developers
Frameworks feel powerful until you look at where they live.
- Framework
- Runtime Environment
- Programming Language
- Compiler or Interpreter
- Machine Code
Frameworks don’t give computers new abilities.
They give humans better ergonomics.
They exist for developer experience in the same way UI exists for user experience.
When things work, you’re at the top.
When things break, the truth is always lower.
You never debug by adding another abstraction.
You debug by going down the pyramid.
Pyramid: Even a Single-Dev MVC App Obeys Gravity
People think architecture starts when teams grow.
It doesn’t.
A solo MVC app already forms a pyramid:
Volatility lives at the top.
Correctness lives at the bottom.
Controllers translate intent.
Models enforce rules.
The database is the costliest thing to change.
If business logic leaks upward, things rot fast.
If the database feels easy to change, you’re lying to yourself.
This isn’t overengineering.
It’s respecting reversibility.
Pyramid: The Modular Monolith Is Gravity Respected
As systems grow, the mistake is usually horizontal.
People spread complexity sideways too early.
Each module:
- owns its rules
- exposes interfaces
- hides internals
Deployment stays boring.
Debugging stays local.
Cost stays predictable.
When scale arrives, extraction is mechanical.
If extraction hurts, the boundaries were imaginary.
Pyramid: Microservices and the Cost of Distribution
Microservices don’t remove complexity.
They move it across the network.
Every network hop is a failure mode.
Every service boundary is a coordination tax.
Microservices solve organizational scale, not early uncertainty.
They are earned through pressure, not ambition.
Used too early, they multiply problems faster than they solve them.
The One Rule Every Pyramid Shares
Across all four pyramids, the rule never changes:
Put things that change often at the top.
Put things that are expensive to change at the bottom.
Frameworks change fast.
Application logic changes more slowly.
Data changes slowest.
Violating this order doesn’t make you modern.
It makes your system fragile.
Why This Mental Model Works
This isn’t philosophy.
It’s reversibility.
The higher the layer:
- the cheaper the mistake
- the easier the rewrite
The lower the layer:
- the higher the cost
- the longer the recovery
Strong systems respect gravity.
Weak systems fight it with abstractions.
Final Thought
Once you see the pyramids, the questions change:
What layer am I touching
How reversible is this decision
And am I adding weight where it doesn’t belong
Top comments (0)