Service · Web development

Custom microservices architecture development.

Whether it's a monolith that no longer scales or a greenfield platform that has to be ready for growth from day one, we design and build microservices architectures in which each service covers its own business capability, can be deployed independently and scales with demand.

Domain-Driven DesignKubernetesEvent streamingAPI gateway

Microservices are not a goal, they are a choice.

A microservices architecture splits your application into independent services, each covering a specific business capability. Order handling, pricing, customer data, notifications: each is its own service, with its own datastore, its own deployment cycle and its own team ownership. The pattern emerged at organisations such as Netflix, Amazon and Spotify, which found that a monolithic codebase with hundreds of engineers gets stuck on coordination, not on technology.

That sounds great, but it is not a free upgrade. Microservices bring complexity: distributed transactions, observability, service discovery, schema evolution, cross-cutting authentication. You trade code complexity for network complexity, and you buy independent deployment cycles at the price of a platform team to keep them running.

We help you decide honestly when microservices are worth it, and when a well-structured modular monolith or platform migration will take you further. When we do build, we build properly: from bounded contexts and an API gateway to an observability stack and GitOps pipelines. Not an experiment, but production-ready architecture that your team can run after we've gone.

Three engagements in which we build microservices.

Which route fits depends on your starting point: a greenfield, a monolith that has ground to a halt, or a multi-system stack after an acquisition. In the first conversation, we'll work out together which engagement suits you best.

Greenfield platform · fixed sprint budget

A new platform from scratch

A new SaaS or platform product that takes multi-tenancy, scale and team velocity into account from the very first service. We start with event storming and Domain-Driven Design, define bounded contexts, and build the first services around your most valuable business capabilities.

DDD workshopService decompositionAPI gatewayEvent streaming
Strangler fig migration · fixed sprint budget

Untangling a monolith, one service at a time

Your monolith still works, but it no longer scales with you. We carve domains out of it step by step using the strangler-fig pattern. First the capabilities with the most velocity pain, such as pricing, search or notifications, and only later the difficult core. The monolith keeps running until the last piece has been extracted.

Bounded contextsAPI gateway routingEvent bridgesData migration
Post-M&A landscape · fixed sprint budget

A service mesh across a mixed landscape

After a merger or acquisition, you're left with multiple stacks, languages and deployment mechanisms. We lay a service mesh (Istio or Linkerd) over the existing systems, harmonise observability and authentication, and migrate the underlying systems to a consistent platform at your own pace.

Service meshmTLSMulti-clusterPolyglot stack

What you get at the end.

A working platform plus the entire runway around it: code, infrastructure, observability, runbooks and a team that can run it themselves. Not just a set of services in production, but the discipline to build new ones.

  • The microservices themselves: production + stagingBackend in Node.js, Spring Boot, .NET, Go or Python (FastAPI), depending on your preferred stack. Deployed on Kubernetes (EKS, GKE, AKS, OpenShift) or Nomad.
  • API gateway + service discoveryKong, Tyk, Apigee or AWS API Gateway as the front door. Service discovery, load balancing, circuit breakers and rate limiting set up as standard.
  • Event-streaming backboneKafka, NATS or RabbitMQ as the asynchronous backbone, with Confluent Schema Registry for schema evolution and backwards compatibility.
  • Observability stackOpenTelemetry instrumentation, distributed traces in Jaeger, metrics in Prometheus, dashboards in Grafana, and structured, searchable logs.
  • CI/CD & GitOpsGitHub Actions or GitLab CI for builds; ArgoCD or Flux for declarative deployments; pull-request preview environments per service.
  • Infrastructure as codeFull infrastructure in Terraform or Pulumi, secrets in HashiCorp Vault or AWS Secrets Manager. Reproducible, auditable, peer-reviewed.
  • Documentation + runbooksArchitecture decision records, sequence diagrams per saga, incident runbooks per service. Your team knows how it works and what to do when it fails.
  • Support contract (optional)Ongoing maintenance, security patches, on-call support and further development, at a fixed monthly fee with clear response times.

When microservices really pay off.

Not every platform benefits from microservices. We help you take an honest look at which patterns you recognise and which route fits your situation. Also read about our related service, cloud-native platform development, for the broader context.

Scaling pressure

The monolith drives up CPU usage and costs

One component peaks on Black Friday, so you scale the entire system. Microservices let you scale out only the busy services, such as pricing, search and checkout, and leave the rest running quietly.

Team velocity

Multiple teams collide in the same codebase

Four teams in one repo, one deployment pipeline, and Friday deployments nobody dares to do. Independent deployment cycles per bounded context give each team its own rhythm and ownership again.

Fault isolation

One bug brings down the entire platform

A memory leak in the reporting module takes your checkout offline. Microservices contain failures: a crashing service only affects the capability behind it, not the rest of your platform.

Polyglot stack

You want the right tool for each problem

Real-time event processing in Go, ML inference in Python, a transactional core in Java. A separate runtime per service means your team can choose the right tool for each problem.

When microservices are not a good idea.

To be honest: for many organisations, a modular monolith is faster, cheaper and less demanding to operate. If you fall into one of these categories, we often recommend a different route.

Team size

Small team, few parallel deployments

For a team of two to five engineers, the operational overhead of microservices is rarely worth it. A well-modularised monolith often scales far enough, and it is much easier to understand in production.

Complexity

Simple application, limited domains

A CRUD application with a handful of entities doesn't deserve ten services. The overhead of a distributed system outweighs the gains: you swap code complexity for network complexity.

Velocity

Low rate of change

If you deploy once a quarter, independent deployment velocity is no gain. The effort you put into pipelines, observability and a service mesh doesn't pay for itself at this scale.

Maturity

No platform team or ops discipline

Microservices demand time invested in DevOps discipline, on-call rotations and an observability culture. Without that foundation, your architecture becomes a minefield instead of a source of freedom.

How a microservices project works with us.

1

Discovery & event storming

Together with your domain experts, we map out which business events actually exist, which commands they trigger, and where the natural boundaries between domains lie. By the end, we know which bounded contexts exist and which services are most worth splitting out. Domain-Driven Design is not an academic exercise here but the foundation of every successful decomposition: wrong boundaries lead to a distributed monolith, the worst of both worlds.

2

Architecture & foundation

A Kubernetes cluster, API gateway, event bus, observability stack, CI/CD pipelines, secrets management and an IaC baseline. A service skeleton that lets your team deploy the first service from top to production. We document the decisions in architecture decision records so later teams understand why Kafka was chosen over NATS, or why Istio and not Linkerd. This phase also includes setting up saga orchestrators for distributed transactions and a schema registry for backwards compatibility.

3

Build in iterations

Each iteration delivers at least one working service with monitoring, tests and a deployment pipeline. We start with the capabilities that have the highest business value or the sharpest velocity pain, and tackle the complex legacy core later.

4

Migration or rollout

With the strangler fig pattern, we migrate route by route via the API gateway, using dual writes and event bridges to the monolith. For greenfield projects, we roll out in phases per business capability, with feature flags for risk management.

5

Knowledge transfer & maintenance

We train your team on the operational side: how to read distributed traces, how to debug sagas, how schema changes work. After that, we optionally provide ongoing maintenance or co-development with your own platform team.

Frequently asked questions.

What clients most often want to know before we start a microservices project.

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.

Talk to us about your microservices architecture.

A no-obligation introductory call of half an hour. We listen to your current situation, whether that's a monolith, a greenfield project or post-M&A, ask sharp questions, and advise on whether microservices really are the right answer. Would you rather see what we've built before first? Take a look at our enterprise software projects.

Edit content