Skip to content

01.01 · Software Architect Deep Dive

Level: Practitioner — Strategic · Reading Time: ~9 mins · Track: Role Alignment Prerequisites: 01 · Roles & Responsibilities

A Software Architect is the custodian of system structure and quality attributes. This deep dive covers what that contract looks like in practice — the artifacts, measurable scenarios, architectural views, and automated governance mechanisms that define modern software architecture.

TL;DR — The 30-Second Mental Model

  • Stay Hands-On by Prototyping Risk: Credible architects don't sit in an ivory tower — they prototype the riskiest 10% of an architecture and verify constraints with code.
  • ADRs Capture Why and What Was Rejected: An ADR without genuine rejected alternatives is a rubber stamp, not architectural reasoning.
  • NFRs Must Be Testable: Replace vague adjectives ("fast, scalable, secure") with SEI Quality Attribute Scenarios (Stimulus → Response → Measure) enforced by automated CI Fitness Functions.

What an Architect Actually Does Day-to-Day

The following is an illustrative allocation, not a universal time benchmark; adjust it to the organization's decision rights, domain risk, and operating model.

Activity Approx. Time Primary Output
Architecture Design & Review 30% ADRs, C4/sequence diagrams, domain boundary specifications
Cross-Team Collaboration 25% API contracts, event schemas, integration patterns
Technical Strategy & Roadmap 20% Technology Radar, multi-quarter modernisation/migration plans
Mentoring & Design Coaching 15% Design review feedback, pairing with tech leads on ADRs
Hands-On Prototyping & Spikes 10% Proof-of-concept benchmarks, fitness function tests, spike code

Answering the 'Are You Still Hands-On?' Question

Interviewers will probe whether you stay technical. The winning answer is not "I write feature code 40 hours a week" — it is:

"I write enough code to stay credible with the engineers building the system: I prototype the highest-risk architectural seams, benchmark candidate technologies under realistic load, and author automated fitness functions in CI."


Architecture Decision Records (ADRs) — Canonical Reference

ADRs (pioneered by Michael Nygard) are the architect's most durable artifact. They create organizational memory by capturing why a decision was made under the constraints of that moment — and what trade-offs were accepted.

Canonical ADR Template

# ADR-{number}: {Short, Action-Oriented Decision Title}

- **Status:** Proposed | Accepted | Deprecated | Superseded by [ADR-XXX]
- **Date:** YYYY-MM-DD
- **Deciders:** {Named Owner (R)}, {Accountable Approver (A)}, {Consulted Teams (C)}
- **Review / Reversal Trigger:** {Date, evidence threshold, or changed constraint that prompts reassessment}

## Context & Problem Statement
What business, technical, or organizational forces forced this decision?
What are the hard constraints (regulatory, timeline, team cognitive load)?

## Decision Drivers (Top Quality Attributes)
1. {e.g., p99 latency < 150ms under 10x flash-sale load}
2. {e.g., Zero cross-region PII egress (GDPR)}
3. {e.g., Operable by a 6-person stream-aligned team}

## Considered Options & Trade-off Matrix
| Option | Pros | Cons / Risks | Verdict |
|:---|:---|:---|:---|
| **Option A (Chosen)** | ... | ... | Accepted |
| **Option B** | ... | ... | Rejected because... |
| **Option C (Status Quo)** | ... | ... | Rejected because... |

## Decision Outcome
We chose **Option A** because it satisfies Drivers 1 and 2 while keeping operational complexity within team bounds.

## Consequences
- **Positive:** What becomes easier or faster?
- **Negative / Accepted Trade-offs:** What becomes harder? What technical debt or operational cost are we knowingly accepting?
- **Compliance / Fitness Function:** How will we verify this decision is respected in CI/production?

The #1 Signal of a Mature ADR

The Considered Options and Negative Consequences sections separate a Principal-level ADR from a junior justification doc. Every real architectural choice has a downside — naming it explicitly builds immediate trust with interviewers and peers.


Quality Attribute Scenarios (SEI Format)

Vague requirements like "the system must be highly available and fast" are untestable. Use the Software Engineering Institute (SEI) 6-part scenario structure to make every quality attribute concrete and falsifiable:

graph LR
    S["1. Source
Who/what triggers it?"] --> ST["2. Stimulus
What event occurs?"] ST --> ENV["3. Environment
Normal, peak, or degraded?"] ENV --> ART["4. Artifact
Which component is hit?"] ART --> R["5. Response
What should the system do?"] R --> RM["6. Response Measure
Quantified pass/fail metric"]

Example: Degraded-Mode Availability Scenario

SEI Field Concrete Specification
1. Source External payment gateway (Stripe)
2. Stimulus Returns HTTP 503 or times out (> 2,000ms)
3. Environment Degraded third-party dependency during peak checkout traffic
4. Artifact Payment Orchestration Service
5. Response Circuit breaker opens after 5 consecutive failures; fails over to secondary PSP (Adyen) or queues idempotent retry
6. Response Measure Checkout success rate remains >= 99.95%; p99 checkout latency stays < 800ms; zero duplicate charges

Core Quality Attributes & Their Inherent Trade-Offs

Quality Attribute Measurable Target Example What It Trades Off Against
Availability 99.99% permitted unavailability (52.6 min/yr) for a defined SLI Redundancy/failover cost; partition-time linearizability (CAP), plus normal-operation coordination latency (PACELC)
Performance (Latency) p99 < 150ms read, p99 < 400ms write Data freshness (caching), hardware cost, query flexibility (denormalisation)
Scalability (Elasticity) Absorb 10× traffic spike in < 60s with < 0.1% errors Stateful simplicity, cross-shard joins, distributed coordination overhead
Security Zero trust mTLS, field-level PII encryption, < 24h critical CVE patch Developer velocity, latency overhead, debugging ergonomics
Maintainability / Evolvability New domain feature deployed independently in < 1 day Upfront modularisation effort, abstraction boilerplate
Observability Critical user journeys propagate context across sync and async hops; alert on correctness and SLO burn Telemetry ingestion/storage and cardinality cost; set a measured telemetry budget and sampling policy

Kruchten's 4+1 View Model

A single diagram cannot serve all stakeholders. Philippe Kruchten's 4+1 View Model separates architecture into four structural/runtime views unified by a fifth validation view (Scenarios):

graph TD
    SC["+1 Scenarios View
Key use cases & quality attribute scenarios
that drive and validate all four views"] LV["Logical View
Audience: Domain experts, Developers
Focus: Domain model, entities, API contracts"] DV["Development View
Audience: Engineers, Tech Leads
Focus: Modules, packages, repo/build boundaries"] PV["Process View
Audience: SREs, System Integrators
Focus: Concurrency, async flows, throughput, fault tolerance"] PHV["Physical View
Audience: Cloud/Platform Engineers
Focus: K8s clusters, regions, VPCs, data residency"] SC --> LV SC --> DV SC --> PV SC --> PHV style SC fill:#F57C00,color:#fff style LV fill:#1976D2,color:#fff style DV fill:#388E3C,color:#fff style PV fill:#7B1FA2,color:#fff style PHV fill:#455A64,color:#fff

Architecture Fitness Functions

Coined in Building Evolutionary Architectures (Ford, Parsons, Kua), an Architecture Fitness Function is an automated, objective check (usually in CI/CD or continuous production monitoring) that prevents architectural drift.

graph LR
    Dev["Developer PR / Commit"] --> CI["CI / CD Pipeline"]
    CI --> FF1["Structural Check
ArchUnit / Dependency Cruiser:
No cyclic or layer-bypassing imports"] CI --> FF2["Contract & Schema Check
Buf / OpenAPI diff:
No breaking backward-compatibility changes"] CI --> FF3["Performance & Security Check
k6 p99 < 250ms & Trivy 0 Critical CVEs"] FF1 --> Gate{"All Pass?"} FF2 --> Gate FF3 --> Gate Gate -->|"Yes"| Deploy["Promote to Prod + Synthetic SLO Monitors"] Gate -->|"No"| Block["Block Merge & Surface Violation"]
Fitness Function Category Tooling Examples What Architectural Drift It Prevents
Modularity & Layering ArchUnit (JVM), Pytest-Archon / import-linter (Python), dependency-cruiser (TS) Domain layer importing infrastructure/DB internals; circular module dependencies
API & Event Contracts Buf (Protobuf), Optic / oasdiff (OpenAPI), Confluent Schema Registry Breaking downstream consumers via unversioned schema mutations
Performance & Latency k6, Gatling, continuous profiling (Parca / Pyroscope) N+1 query regressions or memory leaks degrading p99 latency
Security & Compliance OPA / Rego, Checkov, Trivy, PII log-scanners Unencrypted storage buckets, over-privileged IAM roles, PII leaking into logs

Technology Radar Summary

Architects govern technology sprawl using a Technology Radar (Adopt / Trial / Assess / Hold) so teams standardize on proven defaults while safely experimenting in bounded contexts. (See 07 · Technical Leadership — Technology Radar for the full 4-ring × 4-quadrant governance playbook.)


Primary Architecture References


Common Architect Interview Prompts

  • "Design a global payment ledger or notification platform handling 100k RPS."
  • "How do you decompose a 5-year-old monolith when 15 teams are actively shipping features in it?"
  • "Design a multi-tenant SaaS data architecture that satisfies strict EU/US data residency and noisy-neighbor isolation."
  • "Walk me through the hardest ADR you authored. What option came in second place, and under what future condition would you reverse your decision?"
  • "How do you enforce architectural boundaries across 20 teams without becoming a central review bottleneck?"
  • "A stakeholder asks for 99.999% availability. How do you walk them through the architectural and financial implications?"
  • "How do you balance strong consistency vs. high availability when designing an inventory reservation flow?"

Active Recall & Self-Check

Self-Check 1: Why is relying solely on manual 'Architecture Review Boards (ARBs)' an anti-pattern at scale, and what replaces it?

Answer Rubric: - Manual review boards become scheduling bottlenecks (increasing Lead Time for Changes), encourage teams to hide changes until it's too late to redesign, and rely on human memory rather than objective checks. - Modern Replacement: Combine lightweight asynchronous RFCs/ADRs for high-cost-of-change decisions with automated Architecture Fitness Functions and golden-path templates for routine checks. Measure review wait time, escaped violations, exception age, and false positives; do not assume a fixed percentage of changes should bypass human review.

Self-Check 2: Convert the vague requirement 'Our API must be resilient to downstream database hiccups' into a 6-part SEI Quality Attribute Scenario.

Answer Rubric: - Source: Primary PostgreSQL instance - Stimulus: Experiences a primary-to-replica failover (15 seconds of write unavailability) - Environment: Normal peak traffic (5,000 RPS) - Artifact: Order Ingestion Service - Response: Read endpoints serve from read-replica/cache; write endpoints buffer validated commands in a durable Kafka/SQS queue and return 202 Accepted with a status polling token - Response Measure: 0% HTTP 5xx user-facing errors; 100% of buffered writes persisted within 30 seconds of failover completion.