Software Architecture
Learn the fundamentals of system architecture – enter the world of modern IT design!
Ideal for teams that…
Solid backend and architecture — patterns proven in production.
You will get to know key concepts, roles, and tools of a system architect. You will understand the difference between architecture and design — and when each matters
You will be able to model and document architecture using standard techniques (C4, ArchiMate, UML)
You will learn how to apply Domain-Driven Design, Event Storming, and architectural patterns in practice
You will learn the most important architectural styles: monolith, SOA, microservices, distributed and cloud-based systems
You will practice assessing architectures: measuring, evaluating, presenting architectural decisions
What we actually do
- · Day 1: Foundations of Software Architecture 1.1. Introduction to Software Architecture What software architecture is (and what it is not) Architecture vs design – boundaries of responsibility Architecture as abstraction, recipe, and map Conway’s Law and the influence of organizational structure 1.2. The Role of the Architect and Stakeholders Stakeholders and their impact on the project Stakeholder mapping, communication, and engagement Architect’s competencies and decision-making planning 1.3. Quality Attributes and Non-Functional Requirements Key quality attributes: availability, performance, security, testability, etc. Considering quality attributes from the perspective of users, clients, teams, and business The role of architecture in quality and risk management
- · Day 2: Architectural Styles and System Models 2.1. Classic Architectural Styles Monolith: pros, cons, and modular monoliths SOA (Service-Oriented Architecture): principles, service registry, contracts Modularity and the principle of encapsulation Microservices: benefits, challenges, communication patterns (API Gateway, service discovery) 2.2. Distributed and Cloud-Based Systems Characteristics of distributed systems: scalability, concurrency, fault tolerance Cloud architectures: IaaS, PaaS, FaaS, serverless Deployment models: public, private, hybrid cloud Containerization: Docker, Kubernetes, orchestration 2.3. The 12-Factor App Model Principles for building modern SaaS applications Declarativity, statelessness, configuration, logging, scalability
- · Day 3: System Design in Practice 3.1. Modeling and Documenting Architecture Why we model – asking the right questions before drawing diagrams Model quality: precision, completeness, clarity Modeling languages and notations: C4, ArchiMate, UML, BPMN CASE tools: Visual Paradigm, Sparx EA, StarUML 3.2. Architectural Patterns Styles and patterns: Layered, Hexagonal, Event-Driven, Microkernel Reference architectures Loose coupling and separation of concerns (Single Responsibility Principle) Architectural views and perspectives 3.3. Measuring and Evaluating Architecture How and what to measure in architecture Strategic metrics: KPIs, OKRs Architecture maturity models (CMM) The value of IT: cost center, strategy enabler, catalyst
- · Day 4: Domain-Driven Design and Modern Approaches 4.1. Domain-Driven Design (DDD) The domain and ubiquitous language Service boundaries and bounded contexts Core, supporting, and generic subdomains Strategic and tactical DDD patterns: entities, aggregates, domain services, events Event Storming as a domain discovery method 4.2. Microservices and DDD in Practice When (not) to use microservices Communication strategies (synchronous vs asynchronous) Database per service vs shared database Eventual consistency vs ACID Event-Driven Architecture (EDA) CQRS, Event Sourcing 4.3. Operability and DevOps Configuration management (GitOps, Docker, Terraform, Ansible) Monitoring, logging, and distributed tracing Infrastructure patterns: message broker, materialized views 4.4. API-First & Contracts REST, GraphQL, gRPC – choosing the right technology API documentation and versioning Contract-based integration tests 4.5. Summary and Capstone Designing an architecture from scratch Choosing appropriate styles, patterns, and documentation Presenting and defending architectural decisions
From brief to retro in 30 days.
Brief & diagnosis
A call with the team lead + a short survey for participants. We define goals, gap and context.
Program customization
We adapt modules, case studies and code examples to your stack. Approval in 5 days.
Workshop
Trainer-led sessions, hands-on, code review. Mentor available between sessions too.
Retro + report
Outcome report for the team and lead. 30 days of consulting included.
Send a brief. We'll reply within 1 day.
After a short brief we'll prepare a program and a quote. No obligations — it's just a starting point.
Thank you!
We'll get back to you within 1 business day.
Other programs for teams
See all →Application architecture
Solid backend and architecture — patterns proven in production.
DDD
Solid backend and architecture — patterns proven in production.
Design patterns in C#
Solid backend and architecture — patterns proven in production.