Workshops: Agentic Engineering Practices

Monolith to Microservices with AI Agents: 2-Day Workshop

Breaking up a monolith involves a great deal of mechanical work: tracing dependencies, introducing interfaces, moving code, writing tests around behaviour nobody documented. Coding agents make that work much cheaper, but they do not make the architectural decisions any easier. Over two days your team plans a decomposition, extracts one real capability with agents and secures it with contract tests.

Who is this workshop for?

  • Development teams maintaining a large monolith in Java, .NET, PHP, Python or Node.js
  • Architects planning a decomposition or a modular monolith
  • Tech leads who need to keep shipping features during the migration
  • Platform teams preparing infrastructure for additional services
  • Engineering managers weighing the cost and risk of a re-architecture

What you will take away

  • Decide per module, with explicit criteria, whether to extract a service, draw a boundary inside the monolith or leave the code alone.
  • Identify candidate bounded contexts by combining agent-driven code and git history analysis with your team's domain knowledge.
  • Create seams with agents: interfaces, anti-corruption layers and enforced module boundaries inside the monolith.
  • Extract one capability using the strangler fig pattern, including routing, feature flags and a fallback to the old path.
  • Protect the split with characterisation tests and consumer-driven contract tests, and plan how data ownership moves.

Agenda

  1. Module 1

    Is decomposition the right goal?

    • The cost of distribution: latency, consistency, operations, team load
    • The modular monolith as a serious alternative
    • Decision criteria and a go/no-go per module
  2. Module 2

    Understanding the monolith with agents

    • Dependency and call graphs generated by an agent
    • Hotspots from change frequency and complexity in the git history
    • Event storming with domain experts to validate candidate contexts
  3. Module 3

    Seams and module boundaries

    • Exercise: the agent introduces an interface and an anti-corruption layer
    • Enforcing boundaries with architecture tests
    • Small, reviewable pull requests instead of a big bang
  4. Module 4

    The strangler fig in practice

    • A facade and routing in front of the old code
    • Exercise: extracting one capability end to end with an agent
    • Feature flags, parallel run and rollback
  5. Module 5

    Tests and contracts

    • Characterisation tests before any code moves
    • Consumer-driven contract tests, for example with Pact
    • Agents deriving contract tests from observed calls
  6. Module 6

    Data and the roadmap

    • Splitting data ownership, the outbox pattern and eventual consistency
    • Tracing and monitoring across the new boundary
    • A migration roadmap your team can deliver in increments

What agents change, and what they do not

Decomposition projects used to stall because the mechanical work was so expensive: hundreds of call sites to adapt, tests around undocumented behaviour, code to move without breaking anything. Agents handle much of this quickly, which makes incremental migration far more realistic.

They do not take over the hard part: drawing boundaries that fit your domain and your team structure, handling data consistency and consciously accepting the operating cost of every new service. A badly cut service remains painful even when an agent wrote it.

Typical failure patterns

We work through these patterns explicitly in the exercises, on your own codebase wherever possible:

  • A distributed monolith: services that always have to be deployed together
  • Shared database tables that silently couple services
  • Extraction without tests, so behaviour changes go unnoticed
  • More services than the team can operate
  • Agents moving code faster than reviewers can follow

Two days, one real cut

On day one the team analyses the monolith and decides where to cut; on day two it extracts one capability completely. We work in your repository or, if code must not leave the company, on a sandbox copy. Optional follow-up coaching supports the next extraction steps.

Frequently asked questions

Do we have to end up with microservices?

No. For many teams a well-structured modular monolith delivers many of the benefits with far less operational overhead. The workshop helps you decide, and the boundary work pays off either way.

Can we use our production codebase?

Yes, and it gives the most realistic results. If your policies do not allow the code to be processed by cloud AI models, we work on a sandbox copy, with an approved enterprise set-up or with locally hosted models.

Which languages and frameworks do you support?

We have exercises for Java with Spring, .NET, PHP, Python and Node.js and adapt them to your stack. The patterns themselves, strangler fig, anti-corruption layer and contract tests, are language-independent.

Workshop

Get in touch

Which part of your monolith should be the first to stand on its own?

Tell us roughly how many people will join and pick dates that work – we will get back to you within 24 hours with a proposal for content, format and schedule.

Prefer to talk first?

15 minutes, free and without obligation – with our AI Trainers and AI Code Engineers.

Book a call for free (opens in new tab) +49 761 519 751 50 (24/7)

Request a training / workshop

Workshop: Monolith to Microservices with AI Agents: 2-Day Workshop · 2 days

Dates that work for you (optional)

Suggestions about 2 weeks ahead – pick as many as you like

Reply usually within 24 hours · jocapps is ISO 27001 certified · Privacy