Microservices Decomposition

An honest decision on whether to split at all, boundaries drawn from the domain, data ownership settled, services extracted one at a time and the communication and failure patterns that keep them independent.

Free · Mac (Apple silicon) and Windows · v1.0.5 · Other platforms

Then open the Marketplace in the app, search for Microservices Decomposition, and click Install. It goes into your own files, and works offline from then on.

What it installs.

1

Pillar

1

Area

50

Projects

200

Starter tasks

⚙️ Software Engineering

Microservices Decomposition

Deciding whether and how to split a system into services, drawing service boundaries and handling communication, data ownership and failure.

  1. Module and dependency map of the current system
  2. Written case for or against splitting into services
  3. Change coupling analysis from version control history
  4. Event storming workshop for the core domain
  5. Bounded context map with relationship types
  6. Data ownership matrix for core business entities
  7. Modular monolith boundaries enforced in code
  8. Team agreement on what a service must own
  9. Minimum production bar for any new service
  10. Service catalogue with owners and dependencies
  11. Monthly cross-service call graph review
  12. Consumer contract tests kept green
  13. Event schema registry and compatibility checks
  14. Dead letter queue triage routine
  15. Quarterly boundary health review
  16. Service sprawl and running cost review
  17. Shared library and client SDK drift review
  18. Extraction programme progress tracker
  19. Strategic domain-driven design study
  20. Microservices patterns reading list
  21. Strangler fig practice on a sandbox application
  22. Synchronous and asynchronous communication trade-offs
  23. Saga choreography versus orchestration practice
  24. Transactional outbox and idempotent consumers
  25. Failure handling kata for service calls
  26. Team skills matrix for distributed systems work
  27. Extracting the first service with a strangler fig
  28. Splitting a shared database by service ownership
  29. Choosing between a message broker and an event log
  30. Workflow engine decision for long-running processes
  31. Merging two over-chatty services back together
  32. Event-fed read models instead of cross-service queries
  33. Timeout and retry budget across a call chain
  34. Gateway or backend-for-frontend for client aggregation
  35. Decomposition proposal to leadership
  36. Production cutover of the first extracted service
  37. Data migration day for a split database
  38. Deleting the old monolith code path
  39. First-year decomposition retrospective
  40. Staying on a modular monolith as a small team
  41. Decomposing an enterprise core shared by many teams
  42. Rescuing an inherited distributed monolith
  43. Audit and data residency across service boundaries
  44. Tech lead's first sixty days owning a set of services
  45. Aligning team structure with service boundaries
  46. Consistency model for invariants that span services
  47. Architecture fitness functions for service boundaries
  48. Event sourcing for one high-audit context
  49. Service mesh adoption decision
  50. Independent deployability scorecard

Where it starts.

Each project arrives with its purpose, milestones and first tasks written out. Here is how the first three read.

Module and dependency map of the current system

This is a team plan, best installed into a shared workspace so everyone with a role in it can see and own their tasks. Before anyone argues about services, someone needs to draw what actually exists: the modules, the database tables each one touches and the calls between them.

First tasks

  • Run a dependency graph tool over the main codebase and save the output
  • List which modules read and write each database table
  • Highlight tables written by more than one module
  • Write a one-page summary naming the tangled core and the clean regions

Written case for or against splitting into services

Microservices trade in-process calls for network calls, one deploy for many and one database for several, and that price only pays off when independent deployment or scaling solves a problem you really have. A written case, with the specific pain it would fix and what it would cost in people and tooling, stops the split happening because it is fashionable or blocked because it is scary.

First tasks

  • Write the three problems the split should solve, each with a number behind it
  • Compare a modular monolith, a partial split and a full split against them
  • Estimate the extra pipelines, on-call load and platform work for each option
  • Record the decision and the triggers that would reopen it

Change coupling analysis from version control history

Files that always change together belong together, whatever the folder structure says. Mining a year of commit history for files and modules that move in the same commits shows the real seams of the system and exposes boundaries that look clean on a diagram but would force coordinated releases the moment they became services.

First tasks

  • Export twelve months of commit history with the files touched per commit
  • Calculate how often each pair of modules changes in the same commit
  • List the twenty most tightly coupled module pairs
  • Mark any proposed boundary that would separate a tightly coupled pair

Make it yours.

Install Microservices Decomposition, then tell Aurum the date you're aiming for. It checks whether the plan fits the weeks you actually have.

Free · Mac (Apple silicon) and Windows · v1.0.5 · Other platforms

Blueprints are general information to help you organise your own work. They are not medical, financial, legal or other professional advice. See the Terms.