A product roadmap can make every feature look like a separate service. A delivery plan cannot: each service needs an owner, a data boundary, a deployment path and a failure policy. I would default to a modular monolith for a new .NET product, even when growth is expected, because it lets the team test boundaries before paying to operate them across a network.
A modular monolith wins when the team still changes the same features together
The choice is between a modular monolith—one deployable application with enforced internal boundaries—and .NET microservices—separately deployable applications with explicit contracts. Both can use ASP.NET Core and PostgreSQL; the difference that matters to a product manager is how much independent change the roadmap actually requires. A modular monolith wins when work routinely crosses the proposed boundaries, because one release can carry the coordinated change and one transaction can protect related data. Microservices win when distinct owners must release and scale distinct capabilities without waiting for one another, because a shared deployment has become a delivery constraint.
Those wins have different costs. The monolith costs engineering effort up front to keep modules honest: teams need internal APIs, dependency rules and tests that reject shortcuts into another module’s tables. It also retains one deployment unit, so a defect in shared startup code can affect the whole application. Microservices cost more before the first feature ships: separate build and release pipelines, runtime configuration, service authentication, tracing, alert ownership and procedures for partial failure. A service boundary does not remove coordination when two teams still need to change the same customer action; it moves that coordination into API versions and rollout order.
The existing pattern catalog, Scalable Software Architecture Patterns for Modern Systems, offers names for possible boundaries, but a named pattern is not evidence that a boundary deserves its own deployment. I would not commission a microservice per roadmap theme, because themes change while authentication, data ownership and incident response obligations persist. Ask instead which releases are blocked today by work that another team owns. If the answer is “none,” separate deployment is solving a hypothetical problem with real operating work.
For an initial scope, assume one application and one PostgreSQL 17 cluster; these are planning choices to validate, not capacity promises. Give modules separate schemas or otherwise enforce table ownership, and use architecture tests to prevent direct cross-module references. A single cluster does not require a single undifferentiated data model, because schema ownership can reveal coupling before the team commits to distributed data.
Microservices win when release independence is observable, not aspirational
A separate service is justified when an identifiable capability has its own change cadence and owner, and when a shared release repeatedly delays that capability. For example, suppose a product has four delivery teams and the pricing team cannot release a policy change until an unrelated catalog migration is complete. Those four teams are an illustrative staffing assumption, not a threshold for adopting microservices. The useful evidence is the blocked change: document its cause, duration and affected release before proposing a split.
Independent scaling is another possible reason, but only if the work can actually be isolated. If search requests consume most compute while order writes need steadier latency, a search service may merit its own runtime and scaling policy because additional search replicas would no longer multiply order-processing capacity. If both paths contend on the same PostgreSQL locks or connection limit, splitting the ASP.NET Core processes will not remove the bottleneck; the database work belongs in the scope either way. Redis can relieve particular read patterns, but it should be budgeted as another stateful dependency rather than treated as a free substitute for query design.
The service-design companion, Designing Scalable NET Microservices Architecture at Scale, helps enumerate the obligations of separate services, but I would use that list to challenge a split rather than assume one. A product manager should ask who will own each obligation after launch. HTTP contracts need an OpenAPI definition and compatibility checks because consumers may deploy later than producers. Calls over HTTP or gRPC need timeouts because an unavailable dependency must not hold request resources indefinitely. OpenTelemetry traces need consistent propagation, such as W3C Trace Context, because an incident spanning services cannot be reconstructed from isolated logs.
Do not count “we have Kubernetes” as proof that the service work is funded. Kubernetes can restart a failed container, but it cannot decide whether retrying a payment command is safe or whether a delayed event should still alter an order. A platform team may supply deployment templates and telemetry, which lowers the incremental setup cost; the product team still owns the behavior customers see when dependencies fail. If there is no named owner for that behavior, a modular monolith is the more credible release plan.
A service split costs data and failure decisions, not just API work
Endpoint counts are a poor sizing unit because the difficult work lies between requests. Take an order flow that reads a catalog price, reserves stock and records a purchase. Inside one application, the team may be able to complete related database changes in a PostgreSQL transaction. Once those responsibilities sit behind separate deployments, no ordinary local transaction covers them all. The scope must now say what happens if stock is reserved but the order write fails, or if a customer retries after receiving no response.
That decision changes the backlog. If the flow needs asynchronous updates, an outbox stored alongside the business write can record an event in the same local transaction; a worker then publishes it to RabbitMQ 4 or Apache Kafka, and consumers deduplicate it because delivery may be repeated. An idempotency key on a command protects retries only when the receiving service persists and checks that key. A product requirement such as “the customer sees a confirmed order” therefore needs a precise definition of when confirmation is allowed, not just a ticket to add a queue.
Plan contract and data changes as releases rather than as a single migration. With an expand-and-contract change, the provider first accepts the old and new representation, consumers move, and only then does the provider remove the old field. That sequence costs additional deployment and test work because independent services will briefly run different versions. EF Core 10 migrations can manage a service’s schema, but they cannot make a breaking cross-service contract safe by themselves. The estimate should include consumer tests and a rollback decision for each transition.
Put operational targets into acceptance criteria where they affect user promises. A 99.9% monthly availability target is a proposed value to tune with the business, not a default guaranteed by .NET or Kubernetes. A proposed 2-second checkout timeout likewise needs testing against the actual dependency path, because setting a short timeout without a recovery policy merely changes a slow response into a fast failure. Record p95 request duration using OpenTelemetry’s http.server.request.duration metric, and track queue age separately, because an HTTP response can look healthy while work behind it is falling behind.
For planning, separate the tasks into three funded outcomes: the customer-visible behavior, the contract and data transition, and the failure and recovery behavior. This is not ceremony; a feature can pass its happy-path demo while remaining unsafe to release if duplicate commands or partial writes have no defined outcome. The same breakdown also exposes when the monolith is still cheaper: if one team owns the whole transaction and releases it together, a new queue and compensation path may add risk without granting useful independence.
An exit test makes the monolith a deliberate starting point
A modular monolith should have an extraction test, not a vague promise to “split later.” Start by naming a candidate module, its data owner and every caller. Then require calls to go through an internal interface rather than directly into its tables, because extraction will be expensive if other modules depend on its private model. Keep the first implementation in one process while the team learns whether that interface survives real feature work.
A tiny ASP.NET Core prototype can demonstrate the deployment distinction without pretending that route groups are isolated services. With the .NET 10 SDK installed, this runnable example puts two route groups in one application:
dotnet new web -n ScopeProbe --framework net10.0
cd ScopeProbe
cat > Program.cs <<'EOF'
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.MapGroup("/catalog").MapGet("/{id:int}", (int id) => Results.Ok(new { id }));
app.MapGroup("/orders").MapPost("/", () => Results.Accepted());
app.Run();
EOF
dotnet run --urls http://127.0.0.1:5080
The routes are only a smoke test of one deployment unit; they establish neither module isolation nor production performance. To make the prototype useful for scoping, add separate module projects, forbid direct data access across them and exercise a change that touches both. A split becomes credible when that change can be expressed through a stable contract and the owner can demonstrate how deployment and rollback work independently.
Set a review gate tied to evidence. For example, use a 6-week observation window as a schedule to adjust, and log every release held by another module’s change, every proposed cross-boundary transaction and every incident caused by shared deployment. If Grafana shows an observed p95 of 420 ms over the last 14 days, that measurement belongs in the decision record alongside its traffic conditions; it does not by itself argue for microservices. Latency may point to a query, contention or an external dependency, so require a traced cause before adding a network hop.
Approve extraction only when its specific benefit has an owner and a test: an independent release no longer waits on another team, a separately scaled workload reduces contention, or a fault is contained without breaking the customer promise. Budget the accompanying contract transition, telemetry and recovery drill in the same milestone, because postponing them would make the apparent delivery date misleading.
Fund the boundary experiment before funding the split
At the next planning meeting, pick one proposed service boundary and ask its owner to draw the current data writes, callers and release dependencies on one page. Price a modular version and an independently deployed version against that same customer change. If nobody can name a blocked release or an isolatable workload, authorize the modular version first and schedule a dated review of the evidence.


