You can use the latest technologies . Because you can start developing services independently and
run them side by side (thanks to containers and .NET), you can start using the latest technologies and
frameworks expediently instead of being stuck on an older stack or framework for the whole
application.
Downsides of a microservice-based solution A microservice-based solution like this also has some drawbacks:
Distributed application . Distributing the application adds complexity for developers when they are
designing and building the services. For example, developers must implement inter-service
communication using protocols like HTTP or AMPQ, which adds complexity for testing and exception
handling. It also adds latency to the system.
Deployment complexity . An application that has dozens of microservices types and needs high
scalability (it needs to be able to create many instances per service and balance those services across
many hosts) means a high degree of deployment complexity for IT operations and management. If
you are not using a microservice-oriented infrastructure (like an orchestrator and scheduler), that
additional complexity can require far more development efforts than the business application itself.
Atomic transactions . Atomic transactions between multiple microservices usually are not possible.
The business requirements have to embrace eventual consistency between multiple microservices.
Increased global resource needs (total memory, drives, and network resources for all the servers or
hosts). In many cases, when you replace a monolithic application with a microservices approach, the
amount of initial global resources needed by the new microservice-based application will be larger
than the infrastructure needs of the original monolithic application. This approach is because the
higher degree of granularity and distributed services requires more global resources. However, given
the low cost of resources in general and the benefit of being able to scale out certain areas of the
application compared to long-term costs when evolving monolithic applications, the increased use of
resources is usually a good tradeoff for large, long-term applications.
