Chief Roadblock Remover and Learning Enabler | Software Development Expert | Leadership & Career Coach | Speaker | Author | Building great products, building great teams!

🎯 I'm a result-driven 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗟𝗲𝗮𝗱𝗲𝗿, 𝗦𝗼𝗳𝘁𝘄𝗮𝗿𝗲 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗺𝗲𝗻𝘁 𝗘𝘅𝗽𝗲𝗿𝘁, 𝗖𝗼𝗮𝗰𝗵, 𝗧𝗿𝗮𝗶𝗻𝗲𝗿 𝗮𝗻𝗱 𝗖𝗼𝗻𝘀𝘂𝗹𝘁𝗮𝗻𝘁 with more than 20 years of professional experience in different domains, including the 𝗳𝗶𝗻𝗮𝗻𝗰𝗲 𝗶𝗻𝗱𝘂𝘀𝘁𝗿𝘆, 𝗯𝗮𝗻𝗸𝗶𝗻𝗴, 𝗲𝗻𝗲𝗿𝗴𝘆 𝘀𝗲𝗰𝘁𝗼𝗿, 𝘁𝗿𝗮𝗻𝘀𝗽𝗼𝗿𝘁𝗮𝘁𝗶𝗼𝗻, 𝗶𝗻𝘀𝘂𝗿𝗮𝗻𝗰𝗲 𝗮𝗻𝗱 𝘁𝗲𝗹𝗰𝗼. 

🚀 My mission is to provide 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗲𝘅𝗰𝗲𝗹𝗹𝗲𝗻𝗰𝗲 focused on architecture, the best agile practices, passionately 𝗯𝘂𝗶𝗹𝗱 𝗵𝗶𝗴𝗵-𝗽𝗲𝗿𝗳𝗼𝗿𝗺𝗶𝗻𝗴 𝘁𝗲𝗮𝗺𝘀 𝗮𝗻𝗱 𝗼𝗿𝗴𝗮𝗻𝗶𝘇𝗮𝘁𝗶𝗼𝗻𝘀 to deliver innovative, 𝗵𝗶𝗴𝗵-𝗾𝘂𝗮𝗹𝗶𝘁𝘆 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝘀, working closely with customers and developing software products on different platforms.

🎓 As a 𝗿𝗲𝘀𝗲𝗮𝗿𝗰𝗵𝗲𝗿, I published 20+ papers and book chapters in international conferences and journals (having more than 440+ citations and h-index 11 on Google Scholar), obtaining 𝗣𝗵.𝗗. 𝗶𝗻 𝗖𝗼𝗺𝗽𝘂𝘁𝗲𝗿 𝗦𝗰𝗶𝗲𝗻𝗰𝗲𝘀. Also, I have been involved as a 𝗿𝗲𝘃𝗶𝗲𝘄𝗲𝗿 𝗮𝗻𝗱 𝗽𝗿𝗼𝗴𝗿𝗮𝗺 𝗰𝗼𝗺𝗺𝗶𝘁𝘁𝗲𝗲 𝗺𝗲𝗺𝗯𝗲𝗿, member of ACM, the IEEE Computer Society, and GOAI Research group. 

🧑‍💼 I work as a professional 𝗛𝗶𝗴𝗵-𝗣𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲 𝗮𝗻𝗱 𝗖𝗮𝗿𝗲𝗲𝗿 𝗰𝗼𝗮𝗰𝗵 for people in engineering leadership positions.

✍🏻 Additionally, I am a 𝗽𝗮𝘀𝘀𝗶𝗼𝗻𝗮𝘁𝗲 𝗮𝘂𝘁𝗵𝗼𝗿, who helps more than 400,000 engineers, managers, and architects to build great careers, products, and teams through various platforms and channels.

𝗘𝘅𝗽𝗲𝗿𝘁𝗶𝘀𝗲:

📌 Leadership
📌 Team building
📌 Making things efficient
📌 Creating self-contained systems
📌 Be highly organized and make others too
📌 Focus on strategy/goals
📌 Make things happen
📌 Career Coaching
📌 Mentoring
📌 Line management
📌 Effective client communication
📌 Software Architecture
📌 DevOps mindset
📌 Cloud (Azure)
📌 .NET/C# (ASP.NET/WPF)
📌 SQL Server/NoSQL
📌 Agile methods (Scrum, Kanban, SAFe)
📌 Product/project management

📲 Feel free to contact me here via LinkedIn (DM)!

Dr Milan Milanović

AI writes code faster than you ever will

But it can't decide what problem to solve, which trade-offs to accept, or when the architecture won't hold

The keyboard was never the bottleneck

Your thinking was

And still is

Chief Roadblock Remover and Learning Enabler | Helping 400K+ engineers and leaders grow through better software, teams & careers | Author | Speaker | Leadership & Career Coach

Three algorithm books from MIT Press. All are free to read online.

Mykel Kochenderfer and team published a trilogy that covers ground most engineers actually need:

1. 𝗔𝗹𝗴𝗼𝗿𝗶𝘁𝗵𝗺𝘀 𝗳𝗼𝗿 𝗢𝗽𝘁𝗶𝗺𝗶𝘇𝗮𝘁𝗶𝗼𝗻 (2019)
Linear programming, convex optimization, surrogate models, population methods. The math behind every search and tuning problem you've touched.

2. 𝗔𝗹𝗴𝗼𝗿𝗶𝘁𝗵𝗺𝘀 𝗳𝗼𝗿 𝗗𝗲𝗰𝗶𝘀𝗶𝗼𝗻 𝗠𝗮𝗸𝗶𝗻𝗴 (2022)
Probabilistic reasoning, sequential problems, reinforcement learning, and multi-agent systems. If you're building anything with AI agents, start here.

3. 𝗔𝗹𝗴𝗼𝗿𝗶𝘁𝗵𝗺𝘀 𝗳𝗼𝗿 𝗩𝗮𝗹𝗶𝗱𝗮𝘁𝗶𝗼𝗻 (Preview)
Safety analysis, verification, and robustness testing for autonomous systems. The part most teams skip until something breaks.

I've been going through the Decision Making one recently. The treatment of POMDPs and game-theoretic methods is well worth your time.

Link: https://lnkd.in/dTUjF_xe

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

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

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

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

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 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

I used Ollama to extract structured data from receipt images in .NET.

The interesting part was not sending the image to the model.

It was getting output I could actually use.

A plain text response is not very helpful when you need line items, quantities, and totals.

So I changed the prompt to return JSON and mapped the response directly into C# objects.

That is where this starts to feel practical.

Most of the work was in refining the prompt.

If the model rounded a value, missed a digit, or invented an item, I had to tighten the instructions.

That is the real shift with this kind of workflow.

You write less parsing code, and spend more time making the model return something predictable.

Once the output is structured, the rest feels like normal application code again.

I break down the full implementation here: https://lnkd.in/d_JhHV5k

---

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

𝗖𝗹𝗲𝗮𝗻 𝗰𝗼𝗱𝗲 𝘁𝗶𝗽: 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

taplio

The Battle

Dr Milan Milanović

Milan Jovanović

Followers

Posts

Engagements

Likes

Performance ScoreDr Milan Milanović's LinkedIn Performance

Performance ScoreMilan Jovanović's LinkedIn Performance

Ready to grow your LinkedIn presence?

taplio

The Battle

Dr Milan Milanović

Milan Jovanović

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);}Dr Milan Milanović's LinkedIn Performance

Performance ScoreMilan Jovanović's LinkedIn Performance

Ready to grow your LinkedIn presence?

Performance ScoreDr Milan Milanović's LinkedIn Performance