When are microservices the right choice, and when not?
Microservices are a good choice when there is real scaling pressure, multiple teams wanting to work in parallel, polyglot stack requirements, a need for fault isolation, or independent deployment cycles per business capability. For smaller teams, simple applications or low velocity pressure, a modular monolith is almost always the wiser option. In our first conversation, we help you determine honestly which way to go, and that is a no to microservices more often than you might expect.
What is the difference between a monolith and microservices in practice?
In a monolith, all the business logic lives in one codebase, one deployment and often one database. In a microservices architecture, each business capability is its own service with its own datastore, its own team ownership and its own deployment pipeline. You gain independent scalability and team velocity, but you pay for it with more operational complexity: distributed transactions, schema evolution, observability and a service mesh. A modular monolith sits somewhere in between and is often a good intermediate step.
Do we absolutely need Kubernetes for microservices?
Not strictly, but in practice almost always. Kubernetes (managed via EKS, GKE, AKS or OpenShift) has become the standard for running containerised services with auto-scaling, self-healing and declarative deployments. Alternatives such as HashiCorp Nomad exist and sometimes suit smaller setups better. ECS, Cloud Run or App Runner can work for a handful of services. Beyond ten services and multi-team velocity, Kubernetes almost always wins.
How do you approach a strangler fig migration?
We put an API gateway in front of the monolith and gradually route traffic to new services. For each capability, we identify the bounded context, build the new service with its own datastore, and synchronise data via change data capture or event bridges until the new service becomes the canonical source. The monolith keeps running until the last piece has been moved out. We prioritise the capabilities with the greatest velocity pain or the most scaling pressure, not the hardest core. See also our page on
carrying out a platform migration.
How many services should we have?
As few as possible to solve the problem. The right number comes from your business domain, not from a target figure. Start with coarse bounded contexts (order, customer, pricing, payment, notification) and only split further when a service becomes too big for one team or when deployments start to interfere with each other. Premature decomposition into thirty microservices is one of the most expensive mistakes we come across.
How much should we invest in observability?
A lot, and it is a requirement, not an option. Without distributed tracing (OpenTelemetry, Jaeger or Tempo), structured logs and service-level metrics, a microservices platform is effectively impossible to operate. We design observability as a first-class part of the platform, not as something left for the final sprint. The rule of thumb: if you are not willing to make time for observability, don't choose microservices.
How long does a microservices project take?
That depends heavily on the scope: a greenfield platform with three or four core services can be in production within a project of a few sprints. A full strangler fig migration of a large monolith takes several sprints and often runs in parallel with business as usual. In the discovery phase, we give you a well-founded estimate based on the number of bounded contexts and the complexity of the data migration.
How do you handle compliance (ISO 27001, NIS2, DORA, GDPR)?
Each service gets its own audit trail, encryption in transit and at rest, role-based access via your IdP, and infrastructure as code so that all changes can be reviewed and reproduced. For financial institutions under DORA, we explicitly build for incident reporting, operational resilience and third-party risk. GDPR aspects such as data minimisation and retention policies are handled per service. For systems with strict uptime requirements, we often pair this architecture with a
high-availability systems development project.
Which tech stack do you recommend for services?
We are polyglot. Depending on the capability and your team's skills, we choose Node.js (TypeScript), Spring Boot, .NET, Go or Python (FastAPI) for backend services. For service-to-service communication we usually use gRPC for its type safety and performance, with REST or GraphQL for public APIs. Kubernetes is usually the deployment target, running on AWS (EKS), Azure (AKS), GCP (GKE) or, for cost-conscious setups, on Hetzner with managed Kubernetes. Data per service: PostgreSQL as the default, Redis for caches, Elasticsearch for search, and MongoDB or DynamoDB where document stores are a more natural fit.
How do you handle distributed transactions and data consistency?
In a microservices architecture, classic ACID transactions across multiple services no longer exist. We use the saga pattern, a chain of local transactions with compensating actions on failure, implemented as orchestration (a single central saga coordinator) or choreography (services reacting to each other's events). For read models we use CQRS where it makes sense, with event sourcing for capabilities where a full audit history matters, such as payments or contracts. We are pragmatic: not every service needs event sourcing.