Architecture-first means resolving the decisions that could make the first release unsafe or expensive to change before committing to its implementation. It does not require a complete model of a business that has not found its market yet.
For a startup, the useful result is a small set of decisions the team can build and test: the first customer workflow, its data and permissions, external dependencies, and a way to operate and change the system. A diagram is useful when it explains those decisions. It is insufficient when nobody can turn it into working software.
Start with one complete customer workflow
Consider a client portal where a customer uploads a request, an operator reviews it and the customer receives a result. Before choosing libraries, describe who can perform each step, what counts as acceptance, and what happens if review or delivery fails.
This example is illustrative. Its purpose is to make architectural questions concrete:
- Can customers see only their own requests?
- Does uploading a file create a draft or submit the request?
- Where is the authoritative request status stored?
- Can an operator correct a mistake, and is the change recorded?
- What happens if the notification service is unavailable?
- Can another engineer deploy and recover this workflow?
Keep the first release narrow. Additional roles and integrations can wait; an essential permission check or a reliable submission state usually cannot. Product validation and operational safeguards belong in the same scope discussion.
Define domains and data ownership
A domain is an area of business responsibility, such as identity, requests, billing or notifications. A bounded context gives its concepts a consistent meaning. A billing customer and a person who can log into a portal may be related without being the same record.
For each important record, identify who owns it, which component may change it, and how another component learns that it changed. A shared database can still have clear ownership. Separate databases do not automatically produce it.
In the portal example, the request module owns the review status. A notification failure should not silently change an accepted request back into a draft. An email delivery log is evidence about notification delivery, not the authoritative request record.
Write down the few terms that would otherwise cause disagreement: draft, submitted, accepted, completed and cancelled. These definitions should agree across the interface, API, database and operator instructions.
Describe contracts, including failure
An API contract needs more than a successful JSON response. Define inputs, validation, authentication, resource permissions, expected errors and the meaning of a successful response. Where operations can cause duplicate payments, submissions or external actions, define safe retry behaviour.
For an external integration, also record:
| Decision | What the team needs to know |
|---|---|
| Source of truth | Which system owns the value when two systems disagree |
| Delivery | Whether the exchange uses a direct request, queue, webhook or polling |
| Failure | What is retried, what becomes visible to an operator and who resolves it |
| Compatibility | Which contract versions producers and consumers support |
| Recovery | How missed or duplicate messages are detected and reconciled |
Start with the dependencies the first workflow actually needs. A speculative event platform can create more operational work than the MVP justifies.
Choose a deployment model the team can operate
A modular monolith is often a sensible starting point: one deployable application, with explicit responsibilities inside it. It can support substantial traffic when its database, queries, workloads and infrastructure fit the actual demand.
Microservices can be useful when independent deployment, team ownership, workload isolation or a particular scaling requirement justify the added coordination. They also introduce network failures, distributed tracing, contract compatibility and cross-service recovery. Neither model guarantees scalability or easy maintenance.
Choose the simplest option that meets the known constraints. For the trade-offs in more detail, read monoliths and microservices for early products.
Record assumptions and decisions
An Architecture Decision Record can be short: context, options considered, decision, consequences and the condition that would make the team revisit it. Useful early records might explain tenant isolation, file storage, the billing provider or why a background job is required.
Distinguish a requirement from an assumption. “Customers need access to last month's reports” is different from “we expect ten thousand concurrent users.” Validate the first with the business; investigate the second before buying an infrastructure design around it.
The amount of preparation depends on the workflow and risk. A prototype with disposable data needs less than a product accepting payments or processing confidential documents. There is no universal number of planning days that makes every project ready to build.
Make the first release operable
Before release, connect architecture to evidence:
| Question | Useful evidence |
|---|---|
| Are access boundaries enforced? | Server-side checks covering roles, tenants and denied requests |
| Does the workflow survive failure? | Tested error states, retries and duplicate handling where applicable |
| Can the team release a change? | A reproducible build, deployment instructions and release checks |
| Can data be recovered? | A restore exercise appropriate to the system, with known recovery limits |
| Can someone else continue the work? | Setup instructions, decisions, ownership and known risks |
A successful demo establishes that a particular path worked. It does not establish that the system survives an expired credential, a failed deployment or the departure of its original developer.
If an existing MVP is already difficult to change
Look for small changes breaking unrelated workflows, integrations understood by only one person, manual releases and onboarding that depends on the founder explaining the code. These are reasons to investigate; they do not automatically justify a rewrite.
Map the current behaviour and identify the boundary causing the problem. Capture it with meaningful checks, then make a limited change that can be verified and reversed. Compare the effort and failures involved in similar changes over time. Feature count alone does not show whether delivery is becoming healthier.
For a product that uses Next.js, inspect repeated data requests, sequential external calls, cache ownership and business rules spread through UI components. Framework defects are possible, but a framework migration will not by itself repair an unclear data model or an unreliable integration.
What should remain after architecture work?
The team should have a scoped first workflow, a system and data-flow map, explicit access rules, important interface contracts, deployment and recovery assumptions, a short decision log and a prioritised backlog. Unresolved risks need an owner and a next step.
Our Architecture Sprint describes a defined engagement for reaching that point. MVP and SaaS development starts with a focused production phase from €13,000; the actual scope follows the workflow and its risks. For an existing system, software rescue and takeover or ongoing support may be the more appropriate starting point.
Questions founders ask
Does architecture-first mean designing everything before coding?
No. Resolve the important constraints early, implement a complete narrow workflow, and revise the design using what the team learns. Detailed designs for hypothetical future features can wait.
Does it prevent every rewrite?
No. A business model, platform dependency or operating requirement can change substantially. Explicit boundaries and decisions make the trade-offs easier to assess; they do not guarantee that the original design remains appropriate forever.
Can AI tools do this preparation?
They can help explore options, draft diagrams and inspect code. Someone accountable for the product still needs to validate the business rules, access boundaries, dependencies and operational evidence. Generated documentation is useful only when it describes the system the team actually builds.

