Back to Good: Why Architecture First Is the Only Way Forward

Back to Good: Why Architecture First Is the Only Way Forward

By Mark Kendall, Chief Architect at Kendallsoft

“You don’t build skyscrapers without blueprints. So why are we still writing code before we architect?”

🧱 The Truth: Legacy Isn’t Just Old Code — It’s Bad Architecture

Across companies, industries, and project lifecycles, one pattern keeps repeating: developers are writing code into architectural chaos. We see domain-driven design misapplied. APIs built without a strategy. Services stitched together with brittle adapters. Teams forced into endless refactors, only to arrive at more entropy.

And behind all of it?

No architecture.

Or worse: architecture that’s ignored.

🔍 What Went Wrong?

We forgot something fundamental: architecture is the code. It’s not a slide deck. It’s not a Visio diagram tucked away in Confluence. Architecture defines the constraints, boundaries, contracts, and flows that keep a system resilient, observable, and extensible.

Too often, this gets reversed:

• API-First becomes “Code-First with OpenAPI Last.”

• DDD becomes “entities and services with big dreams but no strategy.”

• CI/CD pipelines become “pipe dreams” when built on foundations of mud.

⚡ The Opportunity: A Renaissance in Architecture

Here’s the good news: AI, modeling tools, and cloud-native patterns have made architecture faster, clearer, and more actionable than ever.

At Kendallsoft, we believe:

• You can build a working enterprise architecture in 3 days.

• You can generate sequence diagrams, context maps, and flowcharts automatically.

• You can translate architecture into code scaffolds, service templates, test plans, and more—automatically.

• You can align teams faster with living architecture artifacts in Git.

The excuse of “we don’t have time” doesn’t hold anymore. We don’t have time not to do architecture first.

🛠️ Architecture First: The New Operating Model

So what does “Architecture First” actually look like?

1. Define Your Canonical Architecture

   
   

   • Start with system boundaries, service responsibilities, and data flows.

   • Define inbound/outbound adapters, core business services, and integration points.

2. 
   

3. Model the Flow

   
   

   • Use sequence diagrams and event-driven maps to model interactions.

   • Define contracts, correlation IDs, and observability touchpoints.

4. 
   

5. Make Architecture Living

   
   

   • Version control your architecture diagrams alongside your code.

   • Generate artifacts: API specs, test harnesses, mapping templates.

6. 
   

7. Push Downstream

   
   

   • Architects define the lane markers, teams drive fast inside them.

   • Every team starts with a clear contract and a shared understanding.

8. 
   

9. Build With Feedback

   
   

   • Architecture evolves through implementation, not despite it.

   • Use feedback loops from observability, testing, and incident analysis.

10. 
    

🔄 Legacy Isn’t the Problem.

Repetition Is.

As a consultant, I make my living cleaning up the same mistakes: projects with great engineers but no alignment. Businesses throwing good money after bad code. Startups racing to MVP and collapsing at scale. Enterprise teams paralyzed by years of integration debt.

Architecture First isn’t a luxury. It’s a necessity.

🌍 A Way Forward in the Age of AI

We are now in a world where AI can generate:

• Architectural templates

• Sequence diagrams

• API specs

• Integration flows

• Deployment plans

But it can’t fix your mistakes. It can’t invent your strategy. It can only scale what you define.

So define it.

Start with architecture. Stay with it. Deliver from it.