Software Architecture
Software Architecture Fundamentals
- Architecture styles: layered, hexagonal (ports & adapters), clean architecture, modular monolith
- Quality attributes: scalability, maintainability, testability — how design decisions trade them off
- ADRs (Architecture Decision Records) as a team practice
- Reading and creating C4 diagrams — context, container, component, code
Microservices Patterns
- Decomposition patterns: by business capability, by subdomain, strangler fig
- Communication patterns: synchronous vs async, API gateway, BFF (Backend for Frontend)
- Resilience patterns: circuit breaker, retry with backoff, bulkhead, timeout
- Data management: database-per-service, shared DB anti-pattern, data consistency trade-offs
Domain-Driven Design (DDD)
- Strategic DDD: bounded contexts, context mapping, ubiquitous language
- Tactical DDD: entities, value objects, aggregates, domain services, domain events
- Event storming workshops — running them with your team
- DDD + microservices: mapping bounded contexts to services, anti-corruption layers
Event-Driven Architecture & CQRS / Event Sourcing
- Event-driven patterns: event notification, event-carried state transfer, event sourcing
- CQRS: Separating read and write models — when it's worth the complexity
- Event Sourcing: Event store design, snapshot strategies, projection rebuilding
- Practical implementation with Axon Framework or custom Kafka-based event store
- Sagas for distributed transactions: choreography vs orchestration
Design Patterns (GoF)
- Creational: Factory, Abstract Factory, Builder, Singleton — when each is appropriate
- Structural: Adapter, Decorator, Proxy, Composite, Facade
- Behavioral: Strategy, Observer, Command, State, Template Method, Chain of Responsibility
- Anti-patterns: anemic domain model, god object, premature abstraction
Engineering Quality
Clean Code & TDD / BDD
- Clean Code: Naming, functions, comments, error handling, boundaries, SOLID principles
- Code smells and refactoring: extract method/class, rename, introduce parameter object
- TDD: Red-green-refactor cycle, outside-in TDD, classic vs mockist schools
- BDD: Given-When-Then, living documentation, acceptance criteria as tests
- Test pyramid — where to invest in unit vs integration vs E2E tests
JUnit 5 & Integration Testing & Cucumber / Gherkin
- JUnit 5: Extensions, parameterized tests, dynamic tests, lifecycle annotations
- Mockito: argument matchers, verification, spy vs mock, stubbing strategies
- Integration testing: Testcontainers for real database/Kafka/Redis in tests, @SpringBootTest slices
- Cucumber: Feature files, step definitions, hooks, data tables, scenario outlines
- Gherkin best practices: writing scenarios that non-developers can read and review
Git & Advanced Workflows
- Branching strategies: Gitflow vs trunk-based development — trade-offs and when to choose
- Interactive rebase, cherry-pick, bisect for debugging, reflog recovery
- Conventional commits, semantic versioning, automated changelogs
- Monorepo strategies: when and how, tooling (Nx, Turborepo, Gradle multi-project)
Frontend
Angular 17+ & React
- Angular: Signals, standalone components, control flow (@if/@for), SSR with Angular Universal, Angular Material
- Angular state management: NgRx, Akita, signal-based stores
- React: Hooks in depth, concurrent features, Suspense, React Query, Context vs Zustand/Jotai
- Performance optimization: memoization, code splitting, bundle analysis
Vue.js & Next.js & TypeScript
- Vue 3: Composition API, Pinia, Vue Router, Nuxt 3 for SSR
- Next.js: App Router, Server Components vs Client Components, ISR, Route Handlers, middleware
- TypeScript: Type system deep-dive, generics, conditional types, template literal types, declaration merging
- TypeScript with React/Angular/Vue — typing components, hooks, and stores correctly
AI & Agentic Development
GitHub Copilot & AI-Assisted Development
- Effective use of Copilot in IDE: prompt patterns, context management, multi-file edits
- AI-assisted code review: what to trust, what to verify, reviewing generated code
- Integrating AI tools into team workflows: norms, review practices, knowledge sharing
- Agentic coding tools: Claude Code, Cursor agent mode, Devin — practical comparison
Prompt Engineering
- Prompting fundamentals: role, context, format, constraints — structuring effective prompts
- Few-shot and chain-of-thought techniques for complex reasoning tasks
- System prompts, prompt injection risks, and evaluation strategies
- Practical prompting for code generation, documentation, test creation, and architecture review
AI + Agentic Development & LangChain / LlamaIndex
- LLM fundamentals: tokens, context windows, temperature, tool use, function calling
- LangChain: Chains, agents, memory, retrievers, LCEL (LangChain Expression Language)
- LlamaIndex: Document ingestion, chunking strategies, vector stores, query engines
- RAG (Retrieval-Augmented Generation): end-to-end architecture, embedding models, reranking
- Agentic systems: tool-using agents, multi-agent orchestration, evaluation and observability
- Building production-ready AI features: latency, cost, hallucination mitigation, guardrails
High demand combination
Architecture + AI is increasingly requested as a pair: Software Architecture fundamentals (Day 1–2) → AI-Assisted Development workshop (Day 3). Teams come away with clearer design thinking and practical tools to integrate AI into their daily work.
Training Formats
Duration
Architecture tracks: 2–3 days. Frontend frameworks: 2–4 days. AI/agentic topics: 1–2 days (rapidly evolving field).
Delivery
On-site or remote. Hands-on labs with your actual codebase where possible — reviewing real code makes theory stick.
Approach
Architecture sessions include design exercises and code review workshops. Frontend sessions are primarily lab-based.
Language
German or English. AI and frontend materials are predominantly in English — German discussion always possible.
Book an Architecture or AI Training
Whether it's a DDD workshop for your architecture team or a practical AI-integration session for your developers — tell me about your context and goals, and I'll shape a training that fits.
Get in touch