Practical .NET and Software Architecture Tips | Microsoft MVP

Hi there! 👋

I'm a senior software engineer, primarily working in the .NET ecosystem.

Things I talk about on LinkedIn:
- C# and .NET ❤
- Software engineering and architecture 
- Distributed systems and how to build them
- Databases and optimization techniques
- Career and personal growth

One of my goals (i̶s̶) was to become a Microsoft MVP in Developer Technologies.
I became an MVP in March of 2023.

If this sounds interesting, let's connect!

Milan Jovanović

Most REST APIs are painful to use.

Here are the top 5 mistakes I see.

It’s not because the logic is bad. It’s because the interface is confusing.

I see developers making the same 5 mistakes over and over:

𝟭. 𝗗𝗲𝗲𝗽 𝗨𝗥𝗟 𝗡𝗲𝘀𝘁𝗶𝗻𝗴: /users/{id}/posts/{id}/comments/{id}. This couples your API to your database structure. Stop it.

𝟮. 𝗣𝗼𝗼𝗿 𝗩𝗲𝗿𝘀𝗶𝗼𝗻𝗶𝗻𝗴: Defaulting to /v1/ without a plan. You are creating a maintenance nightmare for your future self.

𝟯. 𝗜𝗴𝗻𝗼𝗿𝗶𝗻𝗴 𝗣𝗮𝗴𝗶𝗻𝗮𝘁𝗶𝗼𝗻: Returning 10,000 records in one go is the fastest way to kill your database.

𝟰. 𝗜𝗻𝗰𝗼𝗻𝘀𝗶𝘀𝘁𝗲𝗻𝘁 𝗘𝗿𝗿𝗼𝗿𝘀: Returning 200 OK with {"error": "failed"} breaks every client-side convention.

𝟱. 𝗦𝗲𝗰𝘂𝗿𝗶𝘁𝘆 𝗮𝘀 𝗮𝗻 𝗔𝗳𝘁𝗲𝗿𝘁𝗵𝗼𝘂𝗴𝗵𝘁: Bolting on auth at the end never works.

Good API design is about empathy for the developer using it.

I wrote a detailed guide on how to fix these (and what to do instead): https://lnkd.in/dsyi3f7A

---

Do you want to simplify your development process? Grab my Clean Architecture template here and save days of development time: https://lnkd.in/deiKZyNU

undefined undefined

CQRS is a pattern, not a library.

You don't need a mediator to implement it.
You don't need reflection magic.
You don't need "handler discovery".

You just need two interfaces:

- ICommandHandler<T>
- IQueryHandler<T>

When you strip away the libraries, CQRS becomes incredibly simple:

• A class to hold data (The Request)
• A class to process it (The Handler)
• A pipeline for cross-cutting concerns (The Decorator)

If you can't "Go To Definition" on your handler, you've over-engineered it.

Keep your architecture boring.

I wrote a guide on implementing "Vanilla CQRS" from scratch: https://lnkd.in/draXd9t3

---

Do you want to simplify your development process? Grab my Clean Architecture template here and save days of development time: https://lnkd.in/d5aZcFS2

I wanted to build something practical with AI.

So I built a .NET app that scans a receipt photo and turns it into structured data using a local Ollama model + Microsoft.Extensions.AI (MEAI).

This is the part I care about most: making AI output usable in a real app, not just "cool in a demo".

You can use the same pattern for:
- expense tracking
- receipt parsing
- document processing
- internal automation tools

Here's the full breakdown: https://lnkd.in/dZw55gi5

If you are exploring local AI in .NET, this is a great place to start.

No alternative text description for this image

What’s the fastest way to insert 1 million records into your database?

At some point, every app needs to load a LOT of data.

It's smart to optimize this the right way from the start.

Here’s how the main options compare:

𝗘𝗙 𝗖𝗼𝗿𝗲
Simple and familiar. Works fine for smaller batches, but not the fastest.

𝗘𝗙 𝗖𝗼𝗿𝗲 + 𝗘𝘅𝘁𝗲𝗻𝘀𝗶𝗼𝗻𝘀
Faster. Still feels like EF. Good middle ground.

𝗦𝗤𝗟 𝗕𝘂𝗹𝗸 𝗶𝗻𝘀𝗲𝗿𝘁
Fastest option. SqlBulkCopy (SQL Server).
For PostgreSQL, use the COPY command.

See the full benchmark results → https://lnkd.in/d3UMq3j6

---

Do you want to simplify your development process? Grab my Clean Architecture template here and save days of development time: https://lnkd.in/deiKZyNU

𝗪𝗵𝗲𝗻 𝘀𝗵𝗼𝘂𝗹𝗱 𝘆𝗼𝘂 𝘂𝘀𝗲 𝘁𝗵𝗲 𝗢𝘂𝘁𝗯𝗼𝘅 𝗣𝗮𝘁𝘁𝗲𝗿𝗻?

The Outbox pattern stores outgoing messages in a database table, then a background process publishes them to the message broker.

Why bother?

Because in distributed systems, things break: downstream services fail, networks go down.

If you publish messages directly inside your request, you risk losing them when something goes wrong.

The Outbox leverages atomic database transactions:

✅ Save the app state
✅ Save the message to the Outbox (both or nothing)

Later, the background process safely delivers the message.

Just remember: Outbox handles publishing reliability.

On the consumer side, you still need idempotency to handle retries.

Want a deeper dive?

Read the full article here: https://lnkd.in/dKMrmQ3N

Have you worked with the Outbox pattern before?

---

Do you want to simplify your development process? Grab my Clean Architecture template here and save days of development time: https://lnkd.in/d5aZcFS2

If I were starting a new side project in 2026, this is the stack I’d use:

- .NET for the back end
- React + TypeScript for the front end
- Postgres as the default database
- Keycloak for auth
- GitHub Actions for CI/CD
- Hetzner for hosting
- Dokploy or Coolify for deployment

In this video, I walk through each choice and explain the trade-offs.

Here's the full breakdown: https://lnkd.in/dyr_K2bF

This is not about picking the most hyped tools.

It is about choosing a stack that is practical, reliable, and fast to build with, especially for SaaS-style products.

I also cover a few alternatives I’d consider depending on the type of app and how quickly I want to get to production.

If you are building side projects with .NET, this should give you a solid starting point.

What would your 2026 stack look like?

𝗣𝗮𝘁𝘁𝗲𝗿𝗻𝘀 𝗼𝗳 𝗘𝘃𝗲𝗻𝘁-𝗗𝗿𝗶𝘃𝗲𝗻 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲

What does it mean to be event-driven?

In short: an event-driven architecture (EDA) lets decoupled components communicate using events. It’s common in microservice systems, but not exclusive to them.

There are three key parts:

1. 𝗣𝗿𝗼𝗱𝘂𝗰𝗲𝗿𝘀
2. 𝗥𝗼𝘂𝘁𝗲𝗿𝘀
3. 𝗖𝗼𝗻𝘀𝘂𝗺𝗲𝗿𝘀

Producers send events to routers, which forward them to consumers.

But what’s an event?

An event is an immutable fact. Something that already happened and can’t be changed.

Examples:

- Payment received
- Quality control completed
- Suspicious activity detected

Event-driven systems rely on 𝗯𝘂𝘀𝗶𝗻𝗲𝘀𝘀 𝗲𝘃𝗲𝗻𝘁𝘀 to drive decisions.

If you’re using any of these patterns, you’re event-driven:

- Event sourcing → store system state as a series of events
- Event-carried state transfer → pass data between services inside events
- Event notifications → notify someone when something important happens

Want to see how this works with RabbitMQ?

👉 Check out my article: https://lnkd.in/dJYVBytD

What’s your take on event-driven design?

---

Tired of writing the same boilerplate code for every new project? Skip the setup and start building features immediately with my Clean Architecture template: https://lnkd.in/dR6Pp6nU

𝗛𝗼𝘄 𝗩𝗲𝗰𝘁𝗼𝗿 𝗦𝗲𝗮𝗿𝗰𝗵 𝗪𝗼𝗿𝗸𝘀 (and why it matters for .NET devs)

Vector search finds similarity, not just exact matches.

It compares data (text, images, audio) using vector embeddings in a multi-dimensional space.

Why should you care?

✅ It powers AI-driven features: semantic search, recommendations, LLM integrations
✅ You can bring real business value by adding these to your app

Here's a complete example: https://lnkd.in/dNZzG7X4

Are you exploring vector search in your projects yet?

---

Tired of writing the same boilerplate code for every new project? Skip the setup and start building features immediately with my Clean Architecture template: https://lnkd.in/dAitWBiP

I cut a SQL query from 70ms to 1ms.

The fix was surprisingly small: a single filtered index.

Filtered indexes are one of the most underused SQL features.

They let you index only the rows that match a condition, which makes them perfect for cases like `ProcessedAt IS NULL`.

The key is that this only helps when relatively few rows match that filter.

When the selectivity is right, the impact can be huge.

It made a big difference in one of my systems.

I walk through the full implementation in this article: https://lnkd.in/dArkEEcG

---

Tired of writing the same boilerplate code for every new project? Skip the setup and start building features immediately with my Clean Architecture template: https://lnkd.in/dCddeyp7

I cut my .NET hosting bill from “cloud pricing” to ~$3/month... without going back to manual SSH deploys.

I wanted the cloud experience (push-to-deploy, HTTPS, routing, easy databases) but on my own VPS.

So here’s the self-hosting stack I’m using right now:
- Hetzner VPS (cheap + reliable)
- Docker + container images built straight from .NET
- GitHub Actions for CI/CD
- GitHub Container Registry (GHCR)
- Dokploy on the VPS to handle the PaaS layer:
a) reverse proxy + routing
b) automatic HTTPS via Let’s Encrypt
c) deployments via webhook
d) templates for Postgres / Redis / etc.

The workflow is what I actually care about:
push code → build image → deploy automatically

It's a practical setup that scales up to a lot of real apps.

I explain the full pipeline here: https://lnkd.in/dmYTRDNJ

If you’re self-hosting (or thinking about it), I’d love to hear what you’re using.

HybridCache in .NET 10

Should you use it?

HybridCache solves the limitations of IMemoryCache and IDistributedCache.

What does it offer?

- Unified API (in-process + out-of-process caching)
- Configurable serialization
- Stampede protection
- Tag-based eviction

You’ll use GetOrCreateAsync: it checks primary + secondary caches.

On a cache miss, it calls the factory method, stores the result, and returns it.

Here’s how you can start using HybridCache today: https://lnkd.in/dsm4qnjf

Unfortunately, I don't think it's stable for multi-node deployments.

Luckily, FusionCache has a production-ready implementation you can plug into your project. 

Just make sure to run a backplane so everything works correctly.

Are you using HybridCache in your applications?

---

Tired of writing the same boilerplate code for every new project? Skip the setup and start building features immediately with my Clean Architecture template: https://lnkd.in/dR6Pp6nU

What does an API Gateway do?

An API Gateway sits between clients and backend services.

It decides where each request should go.

Core benefits:

- Centralized access
- Abstracts backend services
- Boosts performance

- Handles auth and security

It can also manage:

- Caching
- SSL termination
- Load balancing

In .NET, you can build an API Gateway with YARP.

It makes routing and auth easy.

Here's how: https://lnkd.in/dHAf3VEw

---

Do you want to simplify your development process? Grab my Clean Architecture template here and save days of development time: https://lnkd.in/deiKZyNU

Stop catching architecture violations in Code Reviews.

It’s a waste of your time.

You shouldn't have to leave comments like: "Please remove the reference to Infrastructure in the Domain project".

Automate it.

Treat your architecture rules like unit tests.

If a developer accidentally references the Database from the Core Domain:

❌ The build fails.
❌ They fix it immediately.
❌ You never see the mistake in PR.

This is called Architecture Testing.

It turns "guidelines" into "guardrails".

Here is the library I use to enforce this in .NET: https://lnkd.in/d92b9VrC

---

Do you want to simplify your development process? Grab my Clean Architecture template here and save days of development time: https://lnkd.in/deiKZyNU

Want to build a reliable messaging system?

There's one pattern that you absolutely must master.

The Outbox pattern.

Here’s how it works:

- You add an Outbox table to your database
- Instead of publishing messages to a queue, you store them in the Outbox
- This makes the save + "message" atomic, keeping the system consistent
- A background worker pulls messages from the Outbox and publishes them to a queue

This pattern helps you avoid lost or duplicate messages.

You can implement deduplication on both the publisher and consumer sides.

Want to learn how to apply this in practice?

Complete breakdown: https://lnkd.in/dj8wPzmj

Note: The Outbox pattern gives you at least once messaging guarantees.

---

Tired of writing the same boilerplate code for every new project? Skip the setup and start building features immediately with my Clean Architecture template: https://lnkd.in/dAitWBiP

𝗖𝗹𝗲𝗮𝗻 𝗰𝗼𝗱𝗲 𝘁𝗶𝗽: Replace complex if statements with descriptive methods.

Why?

- Long conditions are hard to read and maintain.
- Refactor the logic into a clearly named method.
- The name explains the intent; the details stay hidden.

It’s a small change that makes a big difference in readability.

What’s your favorite small refactor for cleaner code?

---

Tired of writing the same boilerplate code for every new project? Skip the setup and start building features immediately with my Clean Architecture template: https://lnkd.in/dAitWBiP

𝗗𝗲𝗰𝗼𝘂𝗽𝗹𝗲 𝘆𝗼𝘂𝗿 𝗰𝗼𝗱𝗲 𝘂𝘀𝗶𝗻𝗴 𝗗𝗼𝗺𝗮𝗶𝗻 𝗘𝘃𝗲𝗻𝘁𝘀

Without events:

- Your services become bloated.
- Every new feature adds direct dependencies.
- The code grows... and grows... and grows.

With events:

✅ Publish once, let others react.
✅ No hard dependencies.
✅ Cleaner, smaller services.
✅ Easier to extend in the future.

Want to start using Domain Events in .NET?

👉 Check out the full guide here: https://lnkd.in/dMTUjnjx

---

Do you want to simplify your development process? Grab my Clean Architecture template here and save days of development time: https://lnkd.in/d5aZcFS2

If you can't build a well-structured Monolith, you can't build Microservices.

You will just build "Distributed Spaghetti".

And trust me, a distributed mess is 10x worse than a centralized one.

The Monolith vs. Microservices debate is misleading.

It assumes the only way to decouple code is to put a network between components.

That is expensive:

❌ Latency (Network calls are slow)
❌ Unreliability (What if the network blips?)
❌ Complexity (Eventual consistency, distributed transactions)

The smarter move? The Modular Monolith.

You get the clean boundaries of microservices, but with the speed of in-memory calls.

• Keep the modules.
• Keep the encapsulation.
• Delete the network overhead.

Only split when you need to scale a specific team or feature independently.

Don't pay the "Microservice Tax" until you actually need to.

I wrote a guide on how to architect for modularity first: https://lnkd.in/d9xmk8iz

---

Do you want to simplify your development process? Grab my Clean Architecture template here and save days of development time: https://lnkd.in/deiKZyNU

Want to make your .NET apps more resilient?

Here are 4 simple strategies you can use:

- 𝗥𝗲𝘁𝗿𝘆: try again after a failure
- 𝗧𝗶𝗺𝗲𝗼𝘂𝘁: stop waiting after a limit
- 𝗙𝗮𝗹𝗹𝗯𝗮𝗰𝗸: return a safe value
- 𝗖𝗶𝗿𝗰𝘂𝗶𝘁 𝗯𝗿𝗲𝗮𝗸𝗲𝗿: block failing calls

These tools help your app recover from temporary issues.

.NET developers often use Polly to implement them.

But in .NET 8, there's a new Microsoft Resilience library, built on top of Polly.

Want to learn more?

Here's how to make your apps more resilient: https://lnkd.in/d7UcrJKK

---

Do you want to simplify your development process? Grab my Clean Architecture template here and save days of development time: https://lnkd.in/d5aZcFS2

𝗨𝘀𝗶𝗻𝗴 𝗠𝘂𝗹𝘁𝗶𝗽𝗹𝗲 𝗗𝗮𝘁𝗮𝗯𝗮𝘀𝗲𝘀 𝗶𝗻 𝗮 𝗠𝗼𝗻𝗼𝗹𝗶𝘁𝗵?

Here's why it’s a smart move.

You get strict data isolation between modules.

Why do it?

✅ Prepares for microservices
✅ More control over data access
✅ Lets you extract modules cleanly
✅ Decouples data before splitting services

Think of it as laying the foundation: isolate the data first, then extract the service.

I break down the key details here: https://lnkd.in/dU8rehJd

Have you tried this approach in your architecture?

Note: This doesn't mean you need separate DB servers. It could also be (and usually it's easier) the same DB server. Schemas first, then separate.

---

Tired of writing the same boilerplate code for every new project? Skip the setup and start building features immediately with my Clean Architecture template: https://lnkd.in/dR6Pp6nU

𝗬𝗔𝗥𝗣 𝘃𝘀. 𝗡𝗚𝗜𝗡𝗫: A quick performance comparison

How does YARP stack up against Nginx as a reverse proxy?

I ran performance benchmarks under load:

- NGINX consistently led by ~10–20% in raw throughput
- YARP held steady but was still behind

Here are 3 things you should know:

✅ YARP is native to the .NET
✅ You can extend it using middleware, DI, and more
✅ It integrates seamlessly with all .NET applications

Consider this: sacrifice a bit of speed/throughput. 

But gain flexibility, developer productivity, and better platform alignment.

Full benchmark details here: https://lnkd.in/d-FnBZqe

Which reverse proxy are you using in your stack?

---

Tired of writing the same boilerplate code for every new project? Skip the setup and start building features immediately with my Clean Architecture template: https://lnkd.in/dAitWBiP

Software Engineer Manager at Juniper By IMC

Software Engineer Manager with over 15 years of experience in software development and three years of experience in management. Proficient in various programming languages, including [C#, Node, Javascript, and Python]. 

Experienced in leading cross-functional teams to deliver complex software projects on time and within budget. 

Strong background in agile development methodologies and project management.

Extensive experience in the entire life cycle of the software design process, including requirements definition, prototyping, design, implementation, testing, and maintenance.

Raul Junco

p50, p95, and p99.

How many p's are there, and what do they mean?

Short answer: p = percentile.
It shows how performance is distributed, not the average.

How many “p’s” exist?  
There are percentiles from p0–p100; in practice we usually look at :

• p50 → median
• p90 → early slowdowns
• p95 → SLA baseline
• p99 → tail latency
• p99.9 → ultra reliability systems (Google and Amazon watch p99.9)


Imagine 100 users hitting your API

p50 = 120ms → 50 users were at or faster than 120ms, 50 were slower.
p95 = 800ms → 95 users were at or faster than 800ms, 5 were slower.
p99 = 2.5s → 99 users were at or faster than 2.5s, 1 was slower (this is where frustration lives).


Why track percentiles instead of averages?
Average latency hides pain.

Example:

100ms
110ms
120ms
130ms
5000ms

Average ≈ 1,092ms ❌
p50 = 120ms
p95 = 5000ms ✅

Knowing p50, p95, and p99 helps you:

• spot latency spikes before outages
• understand real user experience
• detect scaling and contention issues
• design safer retries, timeouts, and backpressure
• set meaningful SLAs
• prevent “fast but unreliable” systems

Users don’t experience your average.
They experience your worst moments.

Ignore the tail, and production will remind you.

When did p99 last surprise you?

Distributed Systems are different animals.
Don't build one until you master these 5 things.

1- Distributed transactions

Updating data across many systems can lead to inconsistencies if one update succeeds while another fails.

You need a transactional approach to maintain atomicity.
Use 2PC for strong consistency and atomicity.
Use the SAGAs with compensating actions for eventual consistency.


2- How to deal with a broken service

A single service failure can disrupt the entire system if not properly managed.

Use a Circuit Breaker to isolate failures and fallback mechanisms to maintain system resilience.


3- Retry and Idempotency

Retries handle transient failures, but without idempotency, they can cause duplicates or side effects.

Exponential backoff/Jitter in retry logic to minimize impact on the system.


4- How to handle schema evolution

As systems evolve, data schemas and API contracts need to change. It is challenging to do so without breaking existing services.

• Try to maintain backward and forward compatibility by making additive changes.
• Consider versioning schemas to support many versions at the same time.
• Use an adapter when you need transformation.


5- Observability and Distributed Tracing

Understanding what's happening across a distributed system is hard.

Distributed Tracing and centralized logging are your best friends here. They track and visualize requests across services.

They help identify bottlenecks and troubleshoot issues.

Distributed systems are like juggling flaming torches, impressive, but you'd better know what you’re doing, or things might get hot fast.

Add more points!

taplio

The Battle

Milan Jovanović

Raul Junco

Followers

Posts

Engagements

Likes

Performance ScoreMilan Jovanović's LinkedIn Performance

Performance ScoreRaul Junco's LinkedIn Performance

Ready to grow your LinkedIn presence?

taplio

The Battle

Milan Jovanović

Raul Junco

Followers

Posts

Engagements

Likes

Performance Score.css-goub6s{font-size:var(--chakra-fontSizes-md);font-weight:500;color:var(--chakra-colors-gray-600);display:block;margin-top:var(--chakra-space-1);}Milan Jovanović's LinkedIn Performance

Performance ScoreRaul Junco's LinkedIn Performance

Ready to grow your LinkedIn presence?

Performance ScoreMilan Jovanović's LinkedIn Performance