Software Architect
Grow into a software architect — SOLID, clean architecture, distributed systems, event-driven design, data architecture, resilience, and ADRs. 18 phases from trade-off thinking to architecture case-study interviews.
Your Progress
Complete all 18 phases to master this track
Grow into a software architect — SOLID, clean architecture, distributed systems, event-driven design, data architecture, resilience, and ADRs. 18 phases from trade-off thinking to architecture case-study interviews.
Phase 1: The Architect Role and Trade-off Thinking
Define the architect's responsibilities and frame decisions around quality attributes.
The Role of the Architect
Separate architect responsibilities from those of senior engineers and leads.
Quality Attributes and NFRs
Capture performance, scalability, reliability, and security as testable requirements.
Constraints, Assumptions, and Risks
Inventory the forces that bound a design and flag what could invalidate it.
Trade-off Analysis
Weigh competing quality attributes and present options with explicit costs.
Phase 2: SOLID Principles and Clean Architecture
Apply SOLID and layering rules so codebases stay changeable as teams grow.
Single Responsibility and Open-Closed
Keep classes focused and extend behavior without editing stable code.
Liskov Substitution and Interface Segregation
Keep subtypes interchangeable and interfaces small and purposeful.
Dependency Inversion and Decoupling
Point high-level policy at abstractions so infrastructure can be swapped.
Clean Architecture Layers
Organize code into inward rings where domain rules depend on nothing outward.
Code Smells as Architecture Signals
Read recurring code smells as evidence that module boundaries are drifting.
Phase 3: Design Patterns at Scale
Select standard patterns deliberately and know when they add more cost than value.
Creational Patterns and Factories
Centralize object creation behind factories and controlled lifecycles.
Structural Patterns: Adapter and Facade
Shape foreign interfaces into the contracts your domain expects.
Behavioral Patterns: Strategy and Observer
Swap algorithms at runtime and broadcast state changes to subscribers.
Pattern Selection and Its Trade-offs
Decide when a pattern earns its indirection and when plain code wins.
Phase 4: Layered, Hexagonal, and Modular Monolith Architectures
Structure a single deployable into clear layers, boundaries, and modules.
Layered Architecture
Organize presentation, application, domain, and infrastructure layers in order.
Hexagonal Architecture with Ports and Adapters
Define ports your domain owns and adapters that plug technology into them.
Modular Monolith
Split one deployable into enforced modules that behave like services in embryo.
Bounded Contexts in Domain-Driven Design
Align module boundaries with distinct business languages and models.
Boundaries and Module Coupling
Measure coupling and cohesion to judge whether module cuts are sound.
Phase 5: Microservices Criteria and Service Boundaries
Decide when microservices fit and draw service boundaries that do not thrash.
When Microservices Make Sense
Match microservice costs and benefits to team scale and change patterns.
Service Boundary Decomposition
Carve services along business capabilities rather than technical layers.
Inter-service Communication
Choose between synchronous calls and asynchronous messages for each interaction.
Database per Service
Give each service exclusive data ownership and define how others read it.
Distributed Monolith Pitfalls
Spot services that need joint deploys and fail as one unit anyway.
Phase 6: Distributed Systems Fundamentals
Reason about latency, failure, and ordering when components span machines.
Fallacies of Distributed Computing
Challenge the false assumptions that sink naive distributed designs.
Quantifying Latency and Bandwidth
Estimate round-trip costs to justify co-location and batching decisions.
Fault Models and Failure Modes
Classify crash, omission, timing, and Byzantine faults before designing recovery.
Logical Clocks and Event Ordering
Order events across machines where no global clock is available.
Consensus Overview with Raft
See how replicated nodes agree on state despite crashes and partitions.
Phase 7: Consistency, Replication, and CAP Trade-offs
Choose replication and consistency strategies that match each workload's tolerance.
Replication Fundamentals
Replicate data across nodes for availability and read scale.
Partitioning and Sharding
Split data across nodes with range, hash, or directory strategies.
Consistency Models
Pick strong, causal, or eventual guarantees per operation and audience.
CAP and PACELC Trade-offs
Frame partition-time choices between consistency and availability explicitly.
Phase 8: Messaging and Event-Driven Architecture
Connect services with queues, topics, and events that survive independent failure.
Message Queues and Brokers
Buffer and deliver messages with brokers like Kafka, RabbitMQ, and SQS.
Pub/Sub vs Point-to-Point
Match fan-out broadcasting to topics and work distribution to queues.
Event-Driven Architecture Patterns
Structure producers, event schemas, and consumers for loose coupling.
The Saga Pattern for Transactions
Coordinate multi-service workflows with compensating actions on failure.
Schema Evolution and Compatibility
Change event contracts without breaking older producers or consumers.
Phase 9: Data Architecture: Persistence, CQRS, and Event Sourcing
Select storage styles and models that fit each workload's access patterns.
Relational vs NoSQL Selection
Match SQL, document, key-value, and graph stores to query shapes.
Polyglot Persistence
Let different services use different databases suited to their own needs.
Transactional vs Analytical Workloads
Separate OLTP serving paths from OLAP reporting and their data pipelines.
CQRS Pattern
Split command-side writes from query-side projections and their models.
Event Sourcing
Persist state changes as an append-only log and rebuild state from events.
Phase 10: API Architecture and Contracts
Design versioned API contracts across REST, gRPC, and GraphQL with gateways.
REST Design and Versioning
Model resources, status codes, and version strategies that age gracefully.
Contract-First with OpenAPI
Author the API specification first and generate clients, mocks, and tests.
gRPC and Protobuf Contracts
Define compact binary contracts for efficient internal service calls.
GraphQL Trade-offs
Offer flexible client queries while controlling depth and resolver cost.
API Gateways and Backend-for-Frontend
Terminate cross-cutting concerns at the edge and tailor APIs per client.
Phase 11: Caching and Scalability Architecture
Scale systems horizontally and place caches where they cut real latency.
Vertical vs Horizontal Scaling
Grow capacity by enlarging nodes or by adding more nodes to a fleet.
Load Balancing and Autoscaling
Distribute traffic across instances and resize fleets to demand.
Caching Strategies
Apply cache-aside, write-through, and read-through patterns deliberately.
CDN and Edge Caching
Serve static and cacheable content from points of presence near users.
Cache Invalidation Trade-offs
Keep cached copies correct without destroying the hit rate you built.
Phase 12: Resilience Patterns
Contain failures with timeouts, breakers, bulkheads, and degradation plans.
Timeouts and Retries
Bound waiting time and retry with jitter instead of hammering failures.
Circuit Breaker Pattern
Trip open after repeated failures so callers fail fast instead of queuing.
Bulkheads and Rate Limiting
Isolate pools per workload and cap abuse before it exhausts capacity.
Graceful Degradation and Backpressure
Serve reduced functionality under load instead of failing outright.
Chaos Engineering and Game Days
Inject controlled failures in production to verify resilience claims.
Phase 13: Security Architecture and Zero Trust
Design layered controls and zero-trust boundaries into the system shape.
Architecture-Level Threat Modeling
Identify abuse cases and trust boundaries during design reviews.
Defense in Depth
Stack independent controls so one bypass does not expose the whole system.
Zero Trust Architecture
Verify every request explicitly instead of trusting network location.
Identity and Access Architecture
Choose federation, OAuth flows, and policy models at the system level.
Secrets and Key Management Design
Plan storage, rotation, and blast radius for credentials and encryption keys.
Phase 14: Observability and SRE Alignment
Instrument systems for debugging and align reliability targets with SRE practice.
Logs, Metrics, and Traces
Choose each signal type for the question it uniquely answers.
Distributed Tracing Design
Propagate trace context across queues and workers end to end.
Observability Stack Architecture
Design collection, storage, and dashboards around OpenTelemetry standards.
SLIs, SLOs, and Error Budgets
Set reliability targets and let budgets gate feature vs reliability work.
Designing for Incident Response
Ship runbooks, kill switches, and ownership maps alongside the system.
Phase 15: Integration Patterns and Legacy Modernization
Connect heterogeneous systems and retire legacy without a big-bang rewrite.
Integration Patterns Overview
Choose among file transfer, messaging, and API-based system integration.
Branch by Abstraction
Insert an interface over legacy code so implementations can be swapped gradually.
Strangler Fig Pattern
Route traffic incrementally to new services while the legacy system shrinks.
Anti-Corruption Layer
Translate foreign domain models so legacy concepts never leak inward.
Parallel Runs and Cutovers
Run old and new systems side by side before committing the switch.
Phase 16: Cost, Capacity, and Capacity Planning
Model cost and load ahead of growth so designs stay affordable under demand.
Cloud Cost Model for Architects
Identify compute, storage, and egress drivers before they surprise finance.
Capacity Planning and Forecasting
Project storage, traffic, and compute needs from growth curves.
Sizing Compute, Queues, and Storage
Translate throughput targets into instance counts, queue depths, and disk.
Load Testing to Validate Capacity
Prove capacity assumptions with realistic load and soak tests.
Cost Optimization Patterns
Apply right-sizing, autoscaling, and pricing models to cut waste.
Phase 17: ADRs, Documentation, and Stakeholder Communication
Record decisions durably and adapt architecture communication to each audience.
C4 Model Diagrams
Draw context, container, component, and code views at the right altitude.
Architecture Decision Records
Capture decisions, options, and rationale in a lightweight durable log.
Documentation for Different Audiences
Write separate views for executives, operators, and implementing engineers.
Communicating Trade-offs to Stakeholders
Present architecture options in business language without dumbing down risk.
Design Review Process
Run lightweight reviews that catch flaws before implementation starts.
Phase 18: Architecture Interviews and Case-Study Capstone
Work case studies end to end and narrate decisions in interview settings.
A Framework for Case Studies
Structure open-ended design problems from requirements to a defended proposal.
Back-of-the-Envelope Estimation
Size storage, traffic, and compute quickly with round-number arithmetic.
System Design Interview Walkthrough
Narrate a full design in 45 minutes with defensible trade-offs.
Narrating Trade-off Decisions
Explain why one option won and what was deliberately sacrificed.
End-to-End Architecture Capstone
Produce a complete architecture package with diagrams, ADRs, and review.