How to Balance ‘Good Enough’ Design in Microservice Architecture

Microservice‑oriented architecture is now popular worldwide because it promises faster deployment cycles and lower costs.

For most companies, the main effort is converting existing monolithic applications into microservices, which often creates obstacles and conflicts at many levels.

While a greenfield microservice implementation can strictly follow design principles, legacy applications introduce a "gray area" where budget and time constraints dominate.

Business stakeholders compare the cost of decomposing legacy code with the value it already provides; if costs exceed expected benefits, they may abort the project.

Consequently, development managers feel pressure to deliver code quickly, aiming for a "good enough" solution rather than a perfect one.

Although delivering working code sooner is beneficial, the "gray area" is hard to manage, and defining the boundary of "good enough" becomes a key challenge.

Conflicts arise when one side pushes for rapid delivery while the other seeks more improvements, potentially leading to endless debates that stall progress.

To avoid such conflicts, the article proposes focusing on three questions:

What is the design rationale?

How big is the risk?

What is the plan to mitigate the risk?

1. What is the design rationale?

Evaluating a microservice design requires shifting from past viewpoints to a theoretical analysis, often stemming from breaking down a single application.

A design is considered "good enough" if its benefits and value can be demonstrated.

One common style is event‑driven communication using asynchronous message queues, which offers flexibility and scalability but adds complexity compared to synchronous HTTP APIs.

When time‑to‑market is critical, refactoring monolithic features into independent HTTP‑based microservices can be justified.

Synchronous microservices are usually less complex to implement than asynchronous ones.

与异步服务相比，同步微服务的实现通常不那么复杂。

In the long run, synchronous communication may not be optimal, but for the first version it can be "good enough" given the effort required to extract services from a monolith.

However, synchronous approaches also carry risks, and these must be articulated alongside the design rationale.

2. How big is the risk?

All designs carry inherent risks. In the synchronous example, tight coupling and increased latency are possible drawbacks.

Understanding these risks allows teams to weigh them against the design’s merits; large risks cannot be offset merely by strong rationale.

Some risks may be acceptable given current needs, but they should be clearly communicated during review.

Known risks are preferable to hidden ones, as they can be planned for in future versions.

3. What is the plan to mitigate the risk?

A skilled designer identifies design risks and proposes realistic mitigation strategies; lacking such plans indicates incomplete thinking.

If risks are high and mitigation plans exceed expertise or budget, the design’s feasibility must be questioned.

A well‑balanced microservice design aligns its goals with inherent risks and feasible mitigation measures.

4. Putting it all together

Conflict is an essential part of the creative process; bringing diverse viewpoints together can intensify tension but also drive better solutions.

Using the three‑question framework enables objective discussion, leading to a microservice architecture that works effectively in the short term while remaining flexible for continuous improvement.