I've been (unsuccessfully) trying to coin the phrase "design for deletion": All code in front of you will become unfit and unsalvageable, and your goal is to ensure that when it happens, someone can safely and sanely remove it.

There's overlap with ideas like modularity and decoupling, but the emphasis is different, it shouldn't lead people into architecture-astronautics or trying to be vicariously immoral through their work.

Law of disposable infrastructure: The more temporary a fix is intended to be, the more likely it is to become load-bearing permanent infrastructure

Exactly THIS!

I found an excellent way to avoid premature abstraction and optimization and to write better software in general was to explicitly consider v1.x a throw-away.

Build something expedient that works well enough to deploy in the field, get actual user feedback and system metrics (e.g., where are the actual bottlenecks). Do a few iterations on user feedback and system metrics. NOW, you are much further down the road to a true final spec, and you can use that real information to design the real system to scale up on.

One Test Is Worth A Thousand Opinions.

This plan first tests your ideas against the real world of users, hardware, and data flows, and keeps a lot of technical debt out of the scaling system.

I discovered it a bit by accident, having previously been really big on early abstraction and planning, but sort of having to do this in one startup, and it was a real eye-opener how well it worked.