This post answers “what do we base an architecture on?” without naming a single technology. Afterwards you can list a project’s drivers, see how they pull on each other, and defend a “simple first” decision in front of someone who loves microservices. Documenting decisions (ADRs, quality scenarios) lives in the post on ADRs and quality requirements; weighing trade-offs lives in analysing trade-offs like a senior.
1. What software architecture is, and why it has to change
Key idea: architecture is the set of patterns, principles, processes and relationships that make up the overall design. It evolves with the business: when the business changes, the architecture changes.
There is never a moment of “architecture applied, we can stop caring now”. A system for one gym works fine, then the company buys more gyms, becomes a chain, sells franchises and supplements: the “one branch, one product” assumption collapses. Even when the business stands still, the team’s understanding of it keeps deepening.
To avoid drowning, split the architecture problem into seven areas (divide-and-conquer: break it up and solve each part): business, infrastructure, deployment strategy, solution architecture, testing, release, teams.
The seven areas and the main question in each
| Area | Main question |
|---|---|
| Business analysis | What does the domain look like, which processes matter, where are the boundaries? |
| Infrastructure | Cloud or on-prem, which database and cache, what scale and budget? |
| Deployment strategy | One deployment unit (monolith) or several? |
| Solution architecture | Which patterns where, how do modules talk? |
| Test strategy | Which test levels, how many? |
| Release strategy | How often and how do new versions reach customers? |
| Teams | How are teams split, how experienced are they? |
2. The four groups of architectural drivers
Key idea: drivers are what force the architecture into one shape rather than another. There are four groups, and one of them (quality attributes) is the one people forget.
| Group | What it is | Example |
|---|---|---|
| Functional requirement | What the system must do (not how) | “Assess risk for every new customer before signing a contract” |
| Business constraint | Limits set by the company or outside: time, people, money, law | “Done before event X in 2 weeks”, “only 3 developers”, “GDPR: explicit consent before processing personal data” |
| Technical constraint | Limits from existing technology | “Must run on internal platform A”, “must be Java because the other systems are” |
| Quality attribute | How well the system must do it (non-functional requirement) | “Available ≥ 99.5% per year”, “report A takes ≤ 7 seconds at peak” |
Common quality attributes: maintainability (easy to change), scalability (handles more load without slowing down), performance (fast and efficient), availability (time it is up), security, reliability, complexity (how understandable and manageable it is). Nobody optimises all of them, so pick the few that matter most and write them as numbers.
3. Drivers pull on each other: change one, give up another
Key idea: drivers depend on each other. When one changes, at least one other must change too, and the architect’s job is to state that price before committing.
Original plan: 10 features, a 3-month deadline, run on existing infrastructure, 99% availability. Three common changes:
| Change | Forced consequence |
|---|---|
| Ship the MVP a month earlier, same resources | Cut features |
| Availability 99% → 99.9% | Current infrastructure can’t do it, add components. Either move the deadline or cut features |
| One more mandatory feature in the MVP | Move the deadline (or add people, but adding people mid-project rarely speeds things up) |
flowchart LR
F[Feature scope] --- T[Deadline]
T --- Q[Quality attributes]
Q --- R[Infrastructure and budget]
R --- F
Each extra “nine” sounds small but cuts allowed downtime tenfold:
| Availability | Downtime/year | Downtime/month (30 days) | Typically needs |
|---|---|---|---|
| 99% | ≈ 87.6 h | ≈ 7.2 h | One instance, deploys with downtime are fine |
| 99.5% | ≈ 43.8 h | ≈ 3.6 h | Good backups, deploy out of hours |
| 99.9% | ≈ 8.8 h | ≈ 43 min | ≥ 2 instances behind a load balancer, DB replica with failover, zero-downtime deploys |
| 99.99% | ≈ 53 min | ≈ 4.3 min | Automatic failover within seconds, multiple zones, 24/7 on-call |
How to compute it: downtime = (1 − availability) × total time. For 99.9%: 0.001 × 8,760 h = 8.76 h.
Beyond the time–scope–quality triangle, quality attributes also pull on each other: more complexity means less maintainability, optimising for flexibility can cost performance, and pushing performance usually costs money.
4. Why architecture gets skipped
Key idea: the cost of architecture is visible now, its benefits show up after 2–3 years, so the business easily sees it as waste. The architect’s job is to make that deferred cost visible.
Symptoms of missing architecture: a small change takes two weeks, testing takes a month, fixing one bug creates others. The damage goes beyond engineering: customers lose trust, the best developers leave. How to tell the business: “save $50,000 now, pay $1 million in maintenance over two years”. Record decisions (ADRs) and measure the cost of change (lead time, regressions) to connect year-three results to year-one decisions.
5. Pragmatic and holistic
Key idea: pragmatic means solving the problem you have (or will have within weeks) with real data, not following fixed theory. Holistic means not forgetting any of the seven areas from section 1.
Hearing another company uses microservices makes you want them too: nothing to be ashamed of, but worth being wary of. If you pile up components and only then notice it’s too complex, it’s usually too late, and the only way out is an expensive step-by-step teardown. The pragmatic path:
- Start lean: an MVP in weeks, in front of the first customers.
- With real feedback and traffic, solve real problems: add components for performance, monitoring, scale gradually.
- Decide from observed data, not from “we might need it next year”.
- But keep options open: clear module boundaries, one-way dependencies, so splitting later doesn’t mean demolishing.
Holistic: architects from infrastructure tend to favour infrastructure, those from development favour code. That’s natural, as long as testing, release, security and teams still get attention.
6. Who is a software architect
Key idea: the role has moved from drawing diagrams in an ivory tower to being a team member: coding together, deciding together, living with the consequences together. Often it’s a mindset or a function in the team more than a job title.
What a modern architect does:
- The glue between developers, testers, managers and stakeholders; explains complex things to both sides.
- Understands the domain. Problems repeat across industries (scheduling, payments), so the more industries you’ve seen, the faster you learn a new one.
- A generalist broad enough (business, infrastructure, solution, security, soft skills) to fit the pieces together; specialists go deeper in each.
- A mentor who builds a no-blame environment, and dares to say “stop” when a decision is going wrong.
Gregor Hohpe pictures the architect riding an elevator between the engine room (developers) and the boardroom, connecting business strategy with technical detail.
7. What a successful architecture looks like
Key idea: experienced architects agree on one thing: good architecture is architecture that withstands change. The main tools are modularity and recording why decisions were made.
The three ideas most worth remembering:
- Make uncertainty explicit: wrap an unsure assumption in its own module, so changing your mind touches one place.
- WHY → WHAT → HOW → WITH: understand why (where the money flows), what to build, which class of solution, and only then pick tools.
- Conway’s law: a system mirrors the organisation’s communication structure, so module boundaries only last when they match team boundaries.
Six views from the guest architects, paraphrased
- Make uncertainty explicit. When you must guess (how users will behave, what infrastructure is needed), wrap that assumption in its own module. Changing your mind later touches one module, and you know exactly which (Vlad Khononov).
- Functionality and quality must serve business goals. E-commerce prioritises scale for sales seasons; a healthcare app prioritises security and privacy (Milan Jovanović).
- The WHY → WHAT → HOW → WITH process. WHY: product vision, where the money flows, who the paying customer is. WHAT: what really needs building (Event Storming, Domain Storytelling). HOW: the class of solution (kind of database, deployment, integration), not specific products yet. WITH: pick tools by cost and team experience too. Repeat (Oskar Dudycz).
- Optimise for removability rather than just maintainability: if a piece is easy to remove, a bad idea is easy to drop, and the system becomes easier to maintain as a side effect (Oskar Dudycz).
- Conway’s law: system structure mirrors the organisation’s communication structure. For module boundaries to last, team boundaries must match (Milan Milanović).
- Architecture is a map and a vocabulary: name areas of code like districts in a city, so the next person knows how much they must load into their head (cognitive load) before changing something (Denis Čahuk).
How I record a decision with WHY/WHAT/HOW/WITH
Each big decision records five things, usually in an ADR (template in the post on ADRs and quality requirements):
- Context (WHY/WHAT): which drivers push, with which numbers.
- Choice (HOW/WITH): what we chose, first as a class of solution, then a product.
- Rejected options and why. This is the part most often forgotten, and the most valuable a year later.
- Assumed limits: “this design holds up to ~200 requests per second and 50 GB of data”.
- Evolution path: what to do when the limits are exceeded (“add a read replica for reports, then extract module X”).
Short example: “One deployment unit, a single PostgreSQL 16, one schema per module. Rejected microservices because the 4-person team hasn’t run distributed systems and load is < 50 RPS. Limit: one primary handles current write load with 20x headroom. When module X must scale or deploy independently because of a second team, extract it along the existing schema boundary.”
Familiar technology or the technology that fits better
8. Applied: SaaS for private clinics
Key idea: put the drivers in one table and read the architecture off it. Here, small scale, an inexperienced team and a 2-month deadline all point the same way: one deployment unit with strict modules, on managed infrastructure.
Context (the case running through the book): a SaaS for private clinics in Europe, replacing the spreadsheets the clinics use today.
| Driver | Value | What it implies |
|---|---|---|
| Functional | Scheduling, medical records, treatment, prescriptions, invoicing | 5 business areas, candidates for 5 modules |
| Business: deadline | 2 months | No time to build a distributed platform |
| Business: budget | ≤ $500,000 | Enough for managed infrastructure, no need to run your own cluster |
| Business: law | Health data in the EU (GDPR) | Encrypt sensitive data, audit log, data stays in an EU region |
| Technical | No existing infrastructure, inexperienced team | Prefer managed services and a stack the team knows |
| Quality: availability | 99.5% | ≈ 3.6 h downtime/month: one zone, good backups, out-of-hours deploys are enough |
| Scale | 3–5 clinics, 1,000–1,500 patients, 60–100 staff | Very small load |
Estimate the load to check “very small” is right: 100 staff × ~200 actions/day = 20,000 requests/day. Squeezed into an 8-hour working day: 20,000 / 28,800 s ≈ 0.7 requests/s; multiply by 10 for peak and it’s still ~7 RPS. One Spring Boot instance and one small PostgreSQL have plenty of room.
flowchart TB
U[Staff and doctors] --> APP
subgraph APP[One deployment unit]
A[Scheduling]
T[Treatment]
P[Prescriptions]
M[Medical records]
I[Invoicing]
end
APP --> DB[(Managed PostgreSQL, one schema per module)]
M --> N[National healthcare system]
P --> R[National prescription registry]
This is my own reasoning from the driver table, not the only answer. What’s worth defending when challenged: modules follow business areas (found with the workshops in the post on discovering the domain), each module owns its schema, and modules call each other through in-code interfaces, never reading each other’s tables. When clinics grow into the hundreds, a second team appears, or availability goes to 99.9%, revisit each driver and split exactly where needed.
Exercises
Exercise 1: Drivers change mid-project
In the clinic case, one month in, the business says: (a) a chain of 80 clinics wants to sign and requires 99.9% availability; (b) the deadline stays. List which drivers changed, the impact on the architecture, and what you propose to the business.
Solution to Exercise 1
Changed drivers: scale (5 → ~85 clinics, ~17x), availability (99.5% → 99.9%, downtime/month from 3.6 h to 43 min). Deadline and budget stay, so scope must shrink.
New load: ~85 × 20 staff × 200 actions ≈ 340,000 requests/day ≈ 12 RPS average during working hours, ~120 RPS peak. Still fits a monolith; load is not a reason to split into services.
What 99.9% implies:
- ≥ 2 stateless instances in 2 zones behind a load balancer.
- Managed PostgreSQL with a standby and automatic failover (1–2 minutes, fits in 43 min/month).
- Rolling/blue-green deploys, expand/contract migrations so two versions can run side by side.
- Alerts and an on-call person.
Proposal to the business: keep the deadline but ship the MVP with 3 modules (scheduling, treatment, invoicing), moving e-prescriptions and national records sync to phase 2; or keep all 5 modules and move the date by a month. Include the extra infrastructure cost. Record it as an ADR with a review threshold: “when > 300 clinics or a second team appears, consider extracting scheduling”.
Exercise 2: Write the driver table for your project
Take a project you work on. Write the four driver groups, with a number for every quality attribute. Then point to one component in the current system that no driver asks for.
Hints for Exercise 2
Example, a homestay booking API: functional (search, book, cancel, pay); business (3 developers, launch before Lunar New Year, e-invoices); technical (Spring Boot, existing MySQL); quality (search p95 ≤ 300 ms at 50 RPS, 99.5% availability, never lose a paid booking).
Common unnecessary components: a Redis cache when the table has 20,000 rows and p95 is already 40 ms; Kafka just to send emails when an outbox table and a scheduled job are enough; Kubernetes for one service with one instance. Ask: “if I remove it, which driver is violated?” If you can’t name one, remove it.
Remember
- Name the four groups of architectural drivers, each with a numeric example.
- Explain why going from 99% to 99.9% isn’t “try a bit harder”, and compute the allowed downtime.
- Answer “the deadline moved earlier, what has to change?” without empty promises.
- Tell pragmatic (solve real problems, keep doors open) apart from sloppy (no boundaries at all).
- Describe the modern architect’s role and why Conway’s law affects module boundaries.
Interview questions
Junior
What is the difference between functional and non-functional requirements?
Functional says what the system does; non-functional (quality attributes) says how well it must do it.
“Users search products by keyword” is functional. “Search returns within 300 ms at p95 under 100 requests per second” is non-functional. A non-functional requirement needs a number to be testable.
How much downtime does 99.9% availability allow?
About 8.8 hours a year, roughly 43 minutes a month.
Formula: (1 − 0.999) × 8,760 h = 8.76 h. At 99.99% you get about 53 minutes a year, 4 minutes a month: too short for a human to react, so failover must be automatic.
Mid
What are architectural drivers? Name the four groups.
They’re what forces the architecture into a specific shape: functional requirements, business constraints, technical constraints and quality attributes.
Business constraints cover time, people, budget and law (GDPR). Technical constraints are mandated technologies. Quality attributes are the “-ilities” with numbers. You choose the architecture from these drivers rather than gut feeling or what another company uses.
The PM wants the MVP a month earlier. How do you respond?
It’s possible, but at least one other driver must change: cut scope, temporarily lower a quality target, or add resources (rarely faster).
Rank features by value and cut from the bottom; say clearly what can’t be cut (security, never losing customers’ money); record the technical debt created.
Why does the business often see architecture as waste, and how do you convince them?
Because the cost is visible now and the benefit only shows after a few years. You convince them by turning the deferred cost into numbers tied to business goals.
For example: lead time for a small change, regressions per release, manual testing time. Compare “save 50k now, pay 1 million in two years”. And propose just enough investment (module boundaries, automated tests), not a grand platform.
Senior
How do you keep an architecture simple without closing off the future?
Start with the fewest components the drivers require, but invest in boundaries: modules by business area, data owned by one module, one-way dependencies, and a recorded threshold for revisiting the decision.
- Wrap unsure assumptions in their own module so a change touches one place.
- Enforce boundaries automatically (ArchUnit) instead of relying on review.
- Write ADRs with “assumed limits” and an “evolution path”.
- Optimise for removability: a bad idea should be cheap to remove.
What do you think the architect’s role is in a modern team?
More a function inside the team than a title: understand the domain, connect business and engineering, decide with the team, live with the consequences together, and mentor others.
They still code and review. They’re a generalist broad enough (business, infrastructure, solution, security, soft skills) to fit the pieces together, and they dare to say “stop” when needed. Hohpe’s elevator picture: riding between the engine room and the boardroom, translating strategy into engineering and back.
How does Conway’s law affect architectural decisions?
A system takes the shape of the organisation’s communication paths, so module or service boundaries only last when they match team boundaries.
Two teams changing one module conflict constantly; one team owning five services pays the cost of distribution without the autonomy benefit. Either split modules along teams, or reshape teams to fit the target architecture (the inverse Conway maneuver).
Useful phrases for interviews
- “Before we pick a style, let’s list the architectural drivers.”
- “The two-month deadline is our hardest business constraint.”
- “Availability is the quality attribute that shapes this design the most.”
- “Moving the deadline earlier means we trade off scope.”
- “Microservices aren’t a silver bullet; they mainly solve a team-scaling problem.”
- “A pragmatic first version is a modular monolith on managed Postgres.”
- “Clear module boundaries keep our options open.”
- “Going from three nines to four means failover has to be automatic.”
- “I optimise for removability, so a bad idea is cheap to drop.”
- “Because of Conway’s law, I align module boundaries with team boundaries.”
Notes based on the book Master Software Architecture: A Pragmatic Guide by Maciej “MJ” Jedrzejewski (2024), rewritten in my own words; the estimates, the availability table, the exercises and their solutions are my own.