Software Architect

Overview

About Software Architect

Software architecture is the craft of making the high-level decisions that shape a system: how it is split into parts, how those parts talk, and which trade-offs the team accepts. This course follows the path most engineers take toward the role. It starts with The Architect's Role (responsibilities, stakeholders, and how architects work with teams), then Requirements & Quality Attributes so you can turn business needs into measurable goals.

Next comes Architectural Styles: layered, hexagonal, event-driven, monolith, and microservices. Design Principles & Patterns then covers SOLID, domain-driven design, and the classic design patterns that keep each component clean.

Data Architecture covers choosing between relational, document, and streaming stores, and Distributed Systems & Integration covers messaging, APIs, consistency models, and the CAP theorem. Cloud & Infrastructure and Security Architecture cover where the system runs and how it is protected.

Finally, Scalability & Resilience covers load, failure, and performance planning, and Documentation & Leadership covers C4 diagrams, architecture decision records, and influencing teams: the skills that turn a good designer into a trusted architect.

Content

10 modules
01

The Architect's Role

What architects actually do day to day, how they work with stakeholders and engineering teams, and the difference between enterprise, solution, and software architects.

ResponsibilitiesStakeholdersTrade-offs
02

Requirements & Quality Attributes

Turning business needs into functional requirements and measurable quality goals such as performance, availability, and maintainability.

NFRsSLAs / SLOsQuality Scenarios
03

Architectural Styles

Layered, hexagonal, event-driven, monolithic, and microservice architectures, and how to choose between them for a given problem.

MonolithMicroservicesEvent-Driven
04

Design Principles & Patterns

SOLID, separation of concerns, domain-driven design, and the classic design patterns that keep components cohesive and loosely coupled.

SOLIDDDDDesign Patterns
05

Data Architecture

Choosing the right data stores, modelling for read and write patterns, and designing pipelines from transactional systems to analytics.

SQL vs NoSQLCQRSData Pipelines
06

Distributed Systems & Integration

Service communication, message brokers, consistency models, and the patterns that make independent services work together reliably.

CAP TheoremKafkaSagas
07

Cloud & Infrastructure

Designing for the cloud with containers, orchestration, and infrastructure as code, and weighing cost against flexibility and lock-in.

AWS / Azure / GCPKubernetesTerraform
08

Security Architecture

Threat modelling, identity and access design, secure defaults, and building compliance requirements into the system from the start.

Threat ModellingZero TrustIAM
09

Scalability & Resilience

Planning for load and failure with caching, partitioning, redundancy, and the patterns that keep systems fast and available.

Load BalancingCircuit BreakersObservability
10

Documentation & Leadership

Communicating architecture with diagrams and decision records, evaluating trade-offs, managing technical debt, and guiding teams without micromanaging.

C4 ModelADRsTechnical Debt

What You Can Do After This Course

By the end of the curriculum you'll have worked through 5 hands-on projects and covered the core of what a first software architect role expects. Concretely, you'll be able to:

Define the problem: gather requirements and express quality attributes as measurable targets.

Choose an architecture: compare monoliths, microservices, and event-driven designs, and justify the trade-offs.

Design clean components: apply SOLID, domain-driven design, and proven patterns to keep code maintainable.

Plan data and integration: pick the right stores, define service boundaries, and connect systems with APIs and messaging.

Deploy and secure it: design cloud infrastructure, model threats, and build identity and access control into the system.

Keep it running: plan for scale, failure, and monitoring so services stay available under load.

Communicate and lead: document decisions with C4 diagrams and ADRs, and align teams around a shared technical direction.