Harmonic Framework

One Structure. Every Layer.

Harmonic Design is a unified software engineering framework. It applies a single organizing principle — isolate change along its natural axes — consistently across backend architecture, interface architecture, test strategy, and project planning.

Every long-lived software system has a backend that must evolve, an interface that must evolve, tests that must survive both kinds of evolution, and a project plan that must anticipate, sequence, and resource all three. These concerns are typically governed by separate frameworks and separate mental models. Harmonic Design unifies them under a single structural discipline.

Methodologies

Four methodologies, one structural principle. Each governs a different architectural concern. All share the same decomposition logic.

Volatility-Based Decomposition

Backend systems organized around anticipated change, not current functionality. Components that change for the same reason belong together; components that change for different reasons belong apart.

Experience-Based Decomposition

Interface architecture structured around human intent, not screens. Experiences represent complete user journeys. Flows own goal-directed sequences. Interactions are atomic.

Boundary-Driven Testing

Testing difficulty is architectural evidence. The test spiral is a structural map, not a testing methodology. Correct boundaries produce testable systems; incorrect boundaries produce test friction.

Project Design

Project plans derived from architecture. Components become work packages. Dependencies become the project network. Estimation follows from structural analysis, not intuition.

How They Connect

The same structural map, read across four frameworks. Select an axis to see which roles absorb that category of change.

A business rule changes, a new workflow is added, or orchestration logic shifts — absorbed by Manager and Engine, leaving infrastructure and shared concerns untouched.
An estimate was wrong or new work has been added to the schedule. Nothing in the code changes — the architecture is intact. You adjust the work packages, recalculate the critical path, and re-evaluate float. The same structural decomposition that produced the original plan still governs the updated one.
Non-functional volatility covers the stability qualities: performance, scalability, reliability, availability, extensibility, maintainability, security, and observability. Most are addressed outside the application — scalability through infrastructure, security and observability through cross-cutting Utilities. Extensibility requires a one-time structural investment: expose configuration points, support injection where hardcoded behaviour exists. Once done, new behaviours arrive as configuration, not code. The design itself is the primary answer to most non-functional concerns — which is why a well-decomposed system rarely generates ongoing churn from them.
An external API changes, a database is migrated, a vendor is replaced — absorbed entirely by the Resource Accessor. Nothing above it changes.
Logging standards change, auth conventions shift, observability tooling is replaced — absorbed by Utilities, which are consumed by all tiers but owned by none.
VBD Manager
EBD Experience
BDT Unit · Integration E2E · UAT
Project Design Integration Milestone
VBD Engine
EBD Flow · Interaction
BDT Unit · Integration
Project Design Core Work Package
VBD Resource Accessor
EBD
BDT Unit translation only
Project Design Boundary Work Package
VBD Utility
EBD Utility
BDT Unit
Project Design Shared Infrastructure

Read the framework. Apply the structure.

Start with the methodology that matches your current concern, or read the white papers for the theoretical foundation.

Stay in the loop.