Everything in Software Is a Pyramid (Whether You Like It or Not)

Source: Dev.to

Introduction

After a while, software stops looking like tools.
It starts looking like gravity.
No matter what you build, complexity always sinks downward.
I didn’t plan this model; I just kept noticing the same shape everywhere, so I stopped naming patterns and started drawing pyramids.

Frameworks

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 exist for developer experience in the same way UI exists for user experience. When things work, you’re at the top. You never debug by adding another abstraction.

Architecture

People think architecture starts when teams grow. It doesn’t.
A solo MVC app already forms a pyramid:

• Volatility lives at the top.
• Controllers translate intent.

If business logic leaks upward, things rot fast. This isn’t over‑engineering.

Horizontal Scaling

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. When scale arrives, extraction is mechanical. If extraction hurts, the boundaries were imaginary.

Microservices

Microservices don’t remove complexity; they move it across the network. Every network hop is a failure mode.

• 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 Pyramid Rule

Across all four pyramids, the rule never changes:

Put things that change often at the top.

Frameworks change fast. Violating this order doesn’t make you modern. 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.

Conclusion

Once you see the pyramids, the questions change:

• What layer am I touching?
• How reversible is this decision?
• Am I adding weight where it doesn’t belong?