Modern software architecture is remarkably good at solving today’s problems. It is far less effective at surviving tomorrow.
We have patterns, frameworks, methodologies, and best practices for almost everything: scalability, modularity, testability, deployment, and observability. Yet one variable remains largely implicit and often ignored:
Time
Most software systems are designed to evolve rapidly, but not to endure. As a result, many systems function well in the short term and then gradually lose coherence: business rules leak into infrastructure, architectural decisions become irreversible, and eventually the system is rewritten rather than understood.
This post introduces Legacy-First Design (LFD) a time-oriented architectural methodology that treats longevity not as an emergent property, but as a design constraint.
The problem is not change, it is misplaced change
Change is inevitable. No serious architectural approach denies this.
The real problem is where change is allowed to occur.
In many long-lived systems, architectural decay is not caused by technical limitations, but by a failure to distinguish between what must endure and what may evolve. When permanent business meaning becomes entangled with transient technologies, frameworks, or infrastructure, the system’s identity slowly erodes.
This erosion often manifests as:
- recurring full rewrites
- excessive coupling
- loss of conceptual clarity
- dependency on tribal knowledge
- abandonment followed by replacement
These outcomes are not accidents, they are architectural consequences.
Legacy-First Design in a nutshell
Legacy-First Design (LFD) is a conceptual, decision-oriented architectural methodology that introduces time as a primary axis of architectural reasoning.
Rather than asking only “How should we structure this system?”, LFD asks:
- What must remain valid over time?
- What can change without redefining the system?
- What remains when no one actively maintains the software?
At the core of LFD is a strict distinction between permanence and transience, supported by six fundamental principles:
- Core Centrality
- Separation of Permanence and Transience
- Evolution by Addition, Not Substitution
- Technological Independence of the Core
- Transgenerational Readability
- Survival in Abandoned State
These principles are not implementation rules. They are constraints on architectural decisions.
Survival in Abandoned State
One of the central ideas of LFD is the concept of Survival in Abandoned State.
Most architectural approaches implicitly assume continuous maintenance. LFD does not.
It treats prolonged absence of maintenance as a predictable phase in the software lifecycle. A system that collapses conceptually when abandoned even if it once functioned correctly, has failed architecturally.
Under LFD, systems are designed to:
- remain understandable,
- preserve identity,
- and continue making sense, even when no active development occurs for extended periods.
What LFD is, and what it is not
LFD is not:
- a framework,
- a programming paradigm,
- a replacement for Clean Architecture, DDD, or Hexagonal Architecture.
It operates before those choices.
LFD is compatible with existing architectural styles, but it governs how they are applied by introducing temporal constraints that most methods leave implicit.
The canonical definition
The complete, canonical definition of Legacy-First Design is published as a technical paper, intended to serve as a stable reference point for discussion, critique, and future evolution.
📄 Legacy-First Design (LFD): A Temporal Approach to Software Sustainability
👉 https://zenodo.org/records/18208444
The paper explicitly positions LFD as a conceptual and normative methodology, discusses its relationship with existing approaches, and acknowledges its limitations.
Why this matters
Software systems rarely fail because of a single bad decision.
They fail because of accumulated decisions that did not account for time.
Legacy-First Design does not promise to eliminate complexity or conflict. It proposes something more demanding:
Designing systems that remain coherent when time does its work.
If you are building systems that are expected to last, or inherit systems that already have, this perspective may be worth considering.