The uniformity versus flexibility trade-off

Let's say you have a hundred microservices, but they are all very small and very similar. They all use the same data store (for example, the same type of relational database). They are all configured in the same way (for example, a configuration file). They all report errors and logs to a centralized log server. They are all implemented using the same programming language (for example, Go). Typically, the system will handle several use cases. Each use case will involve some subset of these hundred microservices. There will also be some generic microservices that are used in most use cases (for example, an authorization service). Then, it may not be that difficult to understand the system as a whole, given some good documentation. You can look at each use case separately and, when you extend the system and add more use cases, and maybe grow to a thousand microservices, the complexity remains bounded:

A good analogy is files and directories. Suppose you organize your music by genre, artist, and song. Initially, you had three genres, 20 artists, and 200 songs. Then, you expanded everything and now have 10 genres, 50 artists, and 3,000 songs. The organization is still the same old hierarchy of genre/artist/song. It's true that at some point when you scale, the sheer scale can present new problems. For example, with music, when you have so much music that it doesn't fit on your hard disk, you need a qualitatively different solution (for example, keep it in the cloud). The same is true for microservices, but the divide and conquer approach works well. If you reach internet-scale—Amazon, Google, Facebook—then, yes, you'll need much more elaborate solutions for every aspect.

But, with uniform microservices, you sacrifice a number of benefits. For example, teams and developers may be forced to use a programming language that is not best for the task, or they'll have to abide by strict operational standards of logging and error reporting, even for small non-critical internal services.

You need to understand the pros and cons of uniform versus diverse microservices. There is a spectrum ranging from totally uniform microservices to a jungle of anything goes, where each microservice is a unique snowflake. Your responsibility is to find the sweet spot along this spectrum for your system.