Would you choose the Microsoft stack today if starting greenfield?

One thing that's undervalued about the MS stack in 2026: the interop story. Many teams don't get to choose one stack — they inherit both Java and .NET from acquisitions, vendor integrations, or just different teams making independent choices over the years.

.NET 9's improvements to Native AOT, Dynamic PGO, and container support have made it a genuinely competitive backend choice on its own merits. But the strongest real-world argument for choosing .NET is when you already have Java in the mix and need both to coexist. The tooling for bridging the two ecosystems has matured significantly — shared memory bridges can do sub-millisecond cross-runtime calls, and both Java 21's virtual threads and .NET's async model handle high-concurrency integration well.

If you're truly greenfield with no constraints, pick whichever ecosystem your team knows best. The performance gap between .NET and JVM stacks is negligible in 2026. But if there's even a chance you'll need to integrate with Java libraries or services later, having .NET in the picture gives you options that Go/Rust/Node don't offer as smoothly.

DotNet 10 allows me to create a single web application for all three major platforms, and to ship it with the runtime baked in. This allows me to host said application anywhere I want.

If talking about non-web desktop/mobile software, the big issue comes down to GUI framework. Maui is optimized for mobile, Avalonia is superior on desktop. But other than that, thanks to the baked-in runtime it is becoming trivial to build a single GUI program and have it just run anywhere without significant rework.

Plus, C# has become an absolute pleasure to work with, and makes Java look practically obsolete. Hell, Java had to roll back its own implementation of string interpolation in 2024 because they just couldn’t make it work. C#? Working beautifully since 2015, and improved several times to even greater effect.

And if C#’s functional programming rustles your jimmies, you can easily use F# in the same project without complaint.

Finally, while Blazor webassembly might not be entirely ready for world+dog prime time just yet, it works great in an intranet where thick pipes are guaranteed, allowing me to give a hearty middle finger to everything JavaScript.

Honestly, while I will always evaluate every project to ensure that the programming platform is the best one possible, and have chosen other languages for good reasoning plenty of times. But anything which falls in the “anything will work well enough, generally speaking” bin has me reaching for DotNet almost every time.

I never chose MS, ever. Most systems have been based on Debian servers. Some special needs I've used Alpine Linux and NetBSD (yes it does run on older, limited hardware).

Of course, some potential clients demand MS based solutions. I simply decline those contracts and ring them up 12-18 months later to see if the CTO/CIO has been replaced.

I know it's not popular, but I think Powershell returning objects is quite nice. It seems much better/easier than trying to parse raw text in Linux.

That said, if I'm making something new, I never go with an MS stack. I just wish I had some Powershell type options in Linux from time to time.

The framing assumes teams make a clean "pick one" choice, but in my experience the reality is messier. Most enterprises I've worked with end up running both .NET and Java — not because anyone planned it, but because acquisitions, third-party dependencies, and different team preferences make it inevitable.

The more interesting question might be: how well does your architecture handle having both? Teams that go all-in on one stack often find themselves 3-5 years later integrating with a Java service they inherited through an acquisition, or needing a .NET library that doesn't have a JVM equivalent.

To actually answer the question though: C# and .NET in 2026 are genuinely excellent. The language has evolved faster than Java in many ways (records, pattern matching, LINQ). But Java 21+ has closed the gap significantly with virtual threads, sealed classes, and the continued investment in GraalVM. For a greenfield project, the honest answer is both are fine choices — your team's familiarity matters more than language features at this point.

What I wouldn't do is pick a stack purely based on cloud vendor lock-in. That's the one decision that actually limits your future options.

What's the target?

If you're deploying applications to desktop/laptop, Microsoft stack seems like the biggest market share by a lot.

Anything else, probably not. Microsoft may have advantages in servers, or at least they have had some in the past: my go to example is Receive Side Scaling [1] was originated at Microsoft and is amazing in some use cases. But those advantages most likely aren't big enough to justify the hassle of wrangling and paying for licenses. Running your servers on open source software makes everything easier.

[1] https://learn.microsoft.com/en-us/windows-hardware/drivers/n...

I chose .NET and C# for my current startup (2 years in), where I'm the founding lead developer, and I'd still make the same call today. We've been very productive, built a lot of solid features, and two years in we have a stable, high-performing set of apps. We're using ASP.NET Razor Pages, Web API, backend services, and a .NET MAUI Blazor Hybrid app that's published to the app stores - all written in C# using the latest .NET version. Some parts run in Azure, other parts run on high-performance GPU servers on Ubuntu. It has felt like a very practical modern stack, not some legacy-only enterprise choice. Also, hiring has been a non-issue as I had no trouble finding solid C# developers.

C# is a great language, and .NET is a really good runtime that is cross-platform.

I would personally chose it over Java, and I think it is more "batteries included" than Go.

If you need to write a business/web application that is fairly easy to maintain and has good performance, yes I would pick C#.

Also, while functional programming etc is possible in C#, all the code I've seen has been very Object-Oriented. Classes for days. Dependency injection, factories, and other "Design Patterns" aplently.

Obviously with Python or Node.js you'll likely have an easier time getting off the ground but the performance will be worse (if that matters)

source: SWE manager at MSFT, mostly C# stuff. 10+ YOE with other languages prior to joining

I am building a new product from scratch in .NET. Not the full traditional MS stack but just .NET for backend and VueJS for frontend and Postgres for DB. I don't use things like Azure, SQL Server etc but .NET is solid. So yes.

Microsoft lives off of what Oracle, RedHat, HP or even IBM live off - commercial support. To large corporations, having someone to blame and who can vouch for or guarantee fulfilment of signed contracts means more than anything else, because it gives them legal way to offload responsibility and any legal or financial ramifications in case of a mistake. Windows owning the desktop operating system market, for now, is a clear choice for such services. So it depends on your needs rather than general question for value proposition as that depends solely on your specific requirements.

It depends heavily on the domain. For B2B operations tooling, the real question isn't which stack to build with — it's which ecosystem your customers are already locked into.

If your target users live in Microsoft 365 + Azure AD, the integration advantages of the MS stack are hard to ignore regardless of technical preference. Same goes for teams deep in the Google Workspace or Atlassian ecosystem.

For our greenfield project we went with Kotlin/Spring + Next.js on the basis that most of our target customers use Jira+Confluence, so Atlassian ecosystem familiarity mattered more than stack choice itself.

What are the "best of breed" tools in your opinion?

In the enterprise world, dotnet with c# is one of the best choices, although recently I've been doing a lot of logic just with python running on serverless functions.

Depends on the audience. If it's entrenched enterprise business software? Probably.

Generally, I'd avoid using legacy DotNet and Windows servers for anything I care about. But the reality is that you often can't, outside of the startup space.

I even occasionally use DotNet on Linux and it's very good. I get the sense that the tier 1 platform for DotNet (non-legacy) is Linux, as far as Microsoft engineers are concerned.

Tbh, the only thing that sucks about .NET is their package manager or the entire build process. It just feels more fun to write C# then Java but when it comes down to building the application and general work, its absolute pain. Nuget and all. Gradle just works better in comparison.

TypeScript, C#, F#, Visual Studio, .NET, MAUI, Azure... lots to like and be super productive in.

The only good thing left of microsoft is Typescript language. That’s it.

.NET 10 + Avalonia is rock solid for cross platform UI

Hell no? How is this even a question?

It really depends on the 'time-to-market' requirements. If it's a complex enterprise play, the .NET ecosystem with C# is hard to beat for developer ergonomics and long-term maintenance. However, for a high-performance AI-native startup, I’d likely lean towards a more heterogeneous stack (Python/Rust/Go). The 'Microsoft tax' isn't just about money anymore; it's about the cognitive load of being locked into the Azure-first architectural mindset.