Build a Modular Monolith with an AI Pair
Architecture First, AI Fast: A Hands-On Day of Modular Monoliths and Agentic Development
Your Instructor: Ivan Ball-llovera
Senior Software Architect | 25+ Years Microsoft Stack
Ivan is a Senior Software Architect with 25+ years turning complex business problems into scalable, cloud-native systems on the Microsoft stack. His focus is architecture that lasts: Domain-Driven Design, Clean Architecture, and CQRS applied to real platforms that begin as modular monoliths and extract cleanly into microservices.
He pairs architectural expertise with hands-on Azure and DevOps (Bicep, Docker, Kubernetes, CI/CD, OIDC / Managed Identity) so the designs sketched on a whiteboard actually ship, run, and recover in production. Ivan has led architectural refactors across insurance, government, and enterprise software at Assurant, Hitachi Solutions, and biBERK.
Today he builds production-grade .NET 10 platforms using AI-assisted development (Claude Code, GitHub Copilot) to ship faster without sacrificing quality. Beyond the code, Ivan helps lead the Atlanta tech community as one of the organizers of the Atlanta Cloud + AI Conference and the Atlanta Developers Conference.
Core toolkit: .NET / C#, Blazor, .NET MAUI, ASP.NET Core, .NET Aspire, EF Core, Azure (Container Apps, Service Bus, Cosmos DB, SQL), DDD, CQRS, gRPC, YARP, and the outbox pattern. Bilingual: English / Spanish
When: Full Day (9:00 AM - 5:00 PM)
Where: Improving - 11675 Rainwater Dr #100, Alpharetta, GA 30009
Level: Intermediate .NET developers, tech leads, architects
Workshop Thesis
Good architecture and agentic AI tooling are multipliers of each other: clear boundaries, explicit rules, and executable fitness tests are exactly what make an AI coding agent effective, and the agent is what makes the ceremony of a well-layered system cheap enough to actually build. This workshop teaches both at once by building one system with both.
What This Workshop Is About
Microservices promised independent teams and independent scaling, and delivered distributed debugging, flaky integration environments, and a network hop inside every business transaction. The industry answer is now clear: start with a well-modularized monolith and extract services only when something real (team size, scaling, isolation) forces it. Meanwhile, AI coding assistants went from autocomplete to agents that read, plan, edit, and run tests, and most teams still use them like a fancy search box.
This hands-on workshop teaches both, together, because they reinforce each other. Starting from an empty solution, you will build a modular monolith on .NET 10 with an AI pair (Claude Code) doing the heavy lifting while you make the architectural decisions: rich domain models whose factory methods return results instead of throwing, a hand-rolled CQRS pipeline that gives you validation and logging for free (no frameworks, you will see every line), reliable messaging via the outbox pattern, and architecture fitness tests that fail the build when someone (human or AI) violates a layer rule.
Along the way you learn the agentic workflow that makes it fast: project context files, plan-first prompting, test-driven loops, hooks that make dangerous operations impossible, and reviewing AI diffs like a reviewer instead of rubber-stamping.
The finale keeps the morning's promise twice over: we take a module and run it as its own service behind a YARP gateway with no rewrite, and we let the fitness tests catch the AI breaking a rule, live.
What You'll Build
- A complete modular monolith on .NET 10
- Hand-rolled CQRS pipeline (no frameworks)
- Rich domain models with factory methods
- Reliable messaging via outbox pattern
- Architecture fitness tests
- Extractable microservice behind YARP gateway
What You'll Learn
- Domain-Driven Design building blocks
- Clean Architecture on .NET 10
- Agentic AI workflow patterns
- Test-driven development with AI pairs
- Module extraction strategies
- Production-ready AI coding practices
Prerequisites (sent to attendees ahead of time)
- .NET 10 SDK
- Docker Desktop (SQL Server runs as a container; nothing to install)
- Claude Code installed (CLI or VS Code / JetBrains extension) and signed in; a Claude subscription (Pro or Max) or an API key. Those who cannot use Claude Code can still do every lab by hand; each lab handout includes the manual path.
- Git and an IDE of choice (VS, Rider, VS Code)
Setup clinic available 8:15-9:00 AM for anyone who needs help
Full Day Agenda (9:00 AM - 5:00 PM)
9:00-9:45 AM
Why modular monoliths won, and what AI changesThe microservices hangover; the monolith-first path; what "extractable" actually requires. What an agentic coding tool actually is and why architecture discipline is precisely what makes it effective.
9:45-10:30 AM
Lab 1: Zero to walking skeleton, AI-assistedCreate the blank solution and let the agent scaffold the layer skeleton. Learn to write the context file (CLAUDE.md), use plan mode, and review before approving.
10:30-10:45 AM
Break10:45 AM-12:00 PM
Lab 2: The domain layer - making illegal states unrepresentableDDD building blocks: aggregates, factory methods returning Result<T>, value objects, domain events. Write tests first, let the agent make them pass, review the diff.
12:00-1:00 PM
Lunch1:00-2:15 PM
Lab 3: CQRS by hand, and the decorator pipelineCommands vs queries; hand-rolled decorator pattern for validation and logging. Add complete vertical slices with the agent doing the ceremony.
2:15-3:00 PM
Events and the outbox: reliable messaging without distributed transactionsDomain events vs integration events, why dual writes fail, and the outbox replay pattern. Live demo: kill the process mid-operation and watch the replay.
3:00-3:15 PM
Break3:15-4:00 PM
Lab 4: Fitness tests - rules that bind humans AND the AIArchitecture fitness tests as executable rulesets. Have the agent write the tests, then ask it to violate a rule and watch the build fail.
4:00-4:40 PM
The payoff: second module and extractionAdd a second module. Headline demo: lift the Tickets module out and run it as its own service behind a YARP gateway with no rewrite.
4:40-5:00 PM
Failure gallery, team adoption, wrapReal examples of plausible-but-wrong agent output and verification habits. Take-home starter kit with context file templates and example hooks.
You'll Leave With
- A running solution you built yourself
- A starter kit for your own repos (context file template, example hooks, custom command)
- The habits to use an AI agent on production code without losing engineering discipline
- Public repo with snapshot branches per lab
Ready to Build Better Software with AI?
Secure your spot in this exclusive workshop. Limited seats available!
Register for Workshop Now