|$ curl https://forge-ai.dev/api/markdown?path=docs/architecture/choosing
$cat docs/choosing-architecture-&-sdlc.md
updated Today·25-35 min read·published

Choosing Architecture & SDLC

ArchitectureDecision GuideIntermediate🎯Free Tools
Introduction

This page is a decision aid. Given requirements — team size, domain complexity, latency, consistency, release cadence, compliance — pick an architecture style and an SDLC model that fit. No table replaces judgment, but tables prevent pattern tourism.

Always write the drivers first (Requirements), then consult these matrices, then record the choice as an ADR (Best Practices).

info

If two options seem equal, prefer the simpler one that preserves the option to evolve later — usually a modular monolith with hexagonal boundaries.
Decision Inputs
InputQuestions to answer
Team size & topologyOne team or many? Autonomy needed?
Domain complexityCRUD or rich invariants? Boundary clarity?
ConsistencyStrong ACID across entities? Eventual OK?
Latency / scalep95 targets? Spiky vs steady? Multi-region?
Release cadenceDaily deploys? Quarterly audited releases?
ComplianceTraceability? Data residency? PCI/HIPAA?
Ops maturityCI/CD, on-call, observability ready?
Budget / timeRunway for platform investment?
Architecture Decision Table
SituationPreferAvoid
≤2 teams, evolving productModular monolith + hexagonalMicroservices
Clear domains, many teams, mature platformMicroservices on bounded contextsSingle shared DB
Need vendor/UI swap, rich domainHexagonal / CleanFramework-entangled domain
Simple CRUD, audit wants layersLayered modular appEvent sourcing
Fan-out integration, async workflowsEDA (+ modular or services)Sync call spaghetti
Divergent reads + audit trail MustCQRS ± ES on subdomainGlobal ES everywhere
Spiky load, event glue, cost sensitiveServerless handlersAlways-on overprovision
Hard real-time low latency alwaysAlways-on tuned servicesNaive FaaS on critical path
SDLC Decision Table
SituationPreferNotes
Fixed scope, heavy regulationWaterfall gates / hybridStill prototype risks early
Product discovery, weekly learningScrum or Kanban + DevOpsStrong DoD
Interrupt-driven ops/platformKanbanWIP + flow metrics
Need safe frequent production changeDevOps / continuous deliveryCALMS, not only tools
Marketing release trains + eng agilityHybrid trains + CDFlags decouple release/deploy
Good Combinations

Startup SaaS

Modular monolith + hexagonal + Scrum/Kanban + CI/CD. Extract later with evidence.

Regulated fintech core

Modular monolith or few services + strict ADRs + gated Agile/Waterfall hybrid + traceability.

Multi-team marketplace

Microservices on clear contexts + platform team + DevOps + contract tests.

Internal automation / glue

Serverless + event triggers + Kanban for request flow.

Analytics-heavy product

CQRS read models + EDA from core write models + DevOps for projection deploys.

How to Decide (Workshop)
  • 1. List Must NFRs and constraints on a whiteboard.
  • 2. Score options (monolith, services, EDA, serverless) against each Must.
  • 3. Eliminate options that fail a Must.
  • 4. Among survivors, prefer lower complexity / higher reversibility.
  • 5. Draft ADR with alternatives and revisit triggers.
  • 6. Pick SDLC that matches uncertainty and compliance.
  • 7. Schedule a revisit date (e.g., after 3 months metrics).
decision-scorecard.md
Markdown
1| Driver (Must) | Modular monolith | Microservices | Serverless |
2|-------------------------|------------------|---------------|------------|
3| Team of 6 | ✓ | ✗ | ✓ |
4| Strong checkout ACID | ✓ | ~ | ~ |
5| Deploy 10x/day | ✓ with CD | ✓ | ✓ |
6| Audit trail on ledger | ~ (+audit table) | ~ | ~ |
7Choice: modular monolith; revisit if team > 3 streams
Revisit Triggers

Architecture is not permanent. Revisit when:

  • Team count or topology changes significantly.
  • An NFR repeatedly burns SLO/error budgets.
  • Release coupling blocks independent value streams.
  • Compliance scope expands (new certification).
  • Cost model breaks (cloud bill or engineering time).
Common Mistakes
  • Copying Netflix/Amazon architecture without their scale or platform investment.
  • Choosing microservices to "force modularity" — modularity is cheaper in-process first.
  • Picking Scrum while stakeholders refuse to attend reviews — process without feedback.
  • Ignoring ops maturity — distributed styles need paved roads first.
  • Optimizing for hypothetical hypergrowth while missing near-term delivery.
  • Never writing ADRs — decisions evaporate; new hires re-litigate forever.
  • Treating the choosing table as destiny — context beats slogans.

danger

The most expensive mistake is an irreversible distributed rewrite justified by boredom with the monolith rather than measured drivers.
Quick Reference
If you only remember one thing…Do this
Default structureModular monolith
Default process (product)Agile + DevOps practices
Default documentationADRs + C4 context/container
Default evolutionExtract on evidence, not hype
Default test of readinessCan you state the Must NFRs?
Worked Scenarios

Scenario A — 5 engineers, B2B SaaS

Drivers: fast learning, one team, moderate domain complexity, weekly deploys. Choice: modular monolith + hexagonal ports for billing + Kanban/Scrum + CI/CD. Defer microservices.

Scenario B — 6 stream teams, marketplace

Drivers: independent deploy, clear domains (search, checkout, sellers). Choice: microservices on those seams + platform team + DevOps + contract tests. Avoid shared DB.

Scenario C — Medical device companion app

Drivers: traceability, fixed safety requirements, audited releases. Choice: gated hybrid SDLC + modular monolith with strict ADRs + layered evidence packages.

Scenario D — Spiky image processing

Drivers: burst traffic, cost control, async jobs. Choice: serverless workers on queue + object storage + Kanban for ops requests; API monolith for control plane.

Notice each scenario starts from drivers, not from a favorite pattern. When you present a recommendation, lead with the same structure: drivers → options → choice → risks → revisit triggers.

Architecture × SDLC Matrix
Architecture \ ProcessWaterfall-ishScrumKanbanDevOps CD
Modular monolithOK if gatedExcellent defaultExcellentExcellent
MicroservicesHard without automationNeeds contract focusGood for platformNearly required
EDADocument sagas wellSlice verticallyGood for flowObservability Must
ServerlessRare fitWorksWorksIaC + CI required

Community

Get help on Slack, Discord or VIP

Stuck on a guide? Join the community and ask.