At what point does a microservice architecture become "valuable" compared to a monolithic ASP.NET web application?

In my opinion, the size of the application does not have much to do with the microservice pattern. After all, you can always choose to build some large monoliths or build a monolith from many smaller libraries where it makes sense, or keep it in a large code base using modules / namespaces / packages / whatever-your-language -offers .

The use cases for microservices are to reduce operational complexity and to increase architectural agility.

Operational complexity It is when the central software is not terribly complicated, but every day has serious challenges. Think of Twitter as an example. Your standard business line application is probably solving a more difficult problem than Twitter. After all, I could probably make a quick microblogging application in a weekend. What sets Twitter apart is the service of billions that leads to very different challenges. Microservices help by allowing selective scaling. In combination with other patterns, such as bulkheads and circuit breakers, it facilitates the containment of faults or errors in a part of the system. There are other examples, but I hope this is a good idea.

Architectural agility It is important when you have many teams working on the same system, especially when you don't necessarily have all the what or why it worked from the beginning. The ability to segment the code base by artifact so that teams are less likely to step on each other while they work. In addition, you get the ability to combine multiple languages ​​and frames in ways that you really can't in a monolith.

Of course, these advantages have a price (because all the magic has a price) and that price is that there is an additional complexity injected into the system. The question comes down to whether that complexity buys enough in terms of operations and agility to make it worthwhile. That is very specific for your use case. I imagine that we will see a setback in a few years to run monoliths in cloud infrastructures, followed by a more nuanced balance between the two, where the products choose what makes sense and rise and fall in the spectrum of microservices according to their objectives.