Milan Jovanovic Tech

Founder

Upwork

Senior Software Engineer

HTEC Group

Responsible for major architectural and software design decisions in various in-house projects. Acting as a technical advisor to teams solving challenging problems. Also working as the lead developer for an order placement and processing application for a luxury kitchen manufacturing company.

Application Architect Associate

Responsible for major architectural and design decisions in order placement and processing application for a luxury kitchen manufacturing company. The system has a set of unique challenges from a domain and technology perspective.

I developed a robust Outbox / Inbox messaging system for our event-driven application. Also commonly known as the "Outbox pattern".
The application is split into independent modules, which interact with each other by publishing events.
We needed to process outgoing messages "out of process", to avoid distributed transactions.
We also needed to ensure "at least once" message delivery, and ensure idempotency on the receiving side.

Another one of my responsibilities was application performance, where I focused on the following:
- Ensuring all our SQL queries were optimally written, often investigating the execution plan to make adjustments
- Creating the optimal database indexes for queries processing a large number of records
- Troubleshooting and optimizing algorithms

Developing an order placement and processing system for a luxury kitchen manufacturing company. The application has a set of unique challenges from a domain and technology perspective.

The domain itself is very rich and complex, which is why we have adopted DDD for modeling the core of the system.

We are developing the application itself using the Modular Monolith architecture.
Each Module is implemented with Clean Architecture and CQRS.
Modules interact with each other using messaging, through RabbitMQ.

Software Engineer

Ingsoftware

My responsibilities as a technical lead at Ingsoftware are managing a small development team that consists of front-end and back-end developers. I'm in charge of making important technical decisions aimed at providing the highest quality technical solutions for the present business problems. Communicating with clients (and sometimes stakeholders) on a daily basis and making sure everything is going smoothly.

Apart from these responsibilities, I also regularly take part in the interviewing process for new prospective candidates, as well as work as a mentor for our .NET interns.

Technical Lead

My responsibilities as a software developer at Ingsoftware are:
- Back-end development using C# with ASP.NET Core and .NET Core frameworks,
- Database modeling utilizing SQL Server,
- Proposing efficient and scalable solutions for client requirements,
- Providing accurate LOE estimates for client requirements,
- Mentoring less-experienced teammates and helping them improve (something I truly enjoy),
- Communicating directly with clients,
- Application deployment.

Apart from these responsibilities, I also regularly take part in the interviewing process for new prospective candidates, as well as work as a mentor for our .NET interns.

I won a paid internship through an entry exam that Ingsoftware organized at the annual Job Fair that is held at the Faculty of Electronic Engineering in Niš. The internship helped me learn many new skills that later paved my way into my first employment.

During the internship my responsibilities were:
- Back-end development using C# with ASP.NET MVC and .NET Framework,
- Front-end development using plain vanilla Javascript and Boostrap as a UI framework,
- Using SQL Server for database creation.

.NET Intern

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!

If you're a developer who writes code daily, remember these 5 things:

- First, make it work
- Then make it pretty
- Add safety with lots of tests
- Stay away from over-engineering
- Refactor if needed (and it usually is needed)

Refactoring is your superpower for cleaning up code.

Here are some proven refactoring techniques I use to write better code: https://lnkd.in/e3Z-XBNk

Do you think clean code is overrated?

Milan Jovanović

linkedin.com

li_at

JSESSIONID

LinkedIn

Talks about #csharp, #dotnet, #databases, #softwareengineering, and #softwarearchitecture

I struggled to master Clean Architecture and DDD.

So I prepared 33 lessons to share everything I learned with you.

𝗖𝗹𝗲𝗮𝗻 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 𝗙𝘂𝗻𝗱𝗮𝗺𝗲𝗻𝘁𝗮𝗹𝘀

- Project setup - https://lnkd.in/dqZeKdvU
- Minimal APIs - https://lnkd.in/eKsvdyeQ
- Dependency injection - https://lnkd.in/e7KK27d9
- CA + Document database - https://lnkd.in/eEywJHFS
- Project setup from scratch - https://lnkd.in/dvAVHzzg
- 4 Best practices for new project - https://lnkd.in/dPfxPfuY
- Structured logging - https://lnkd.in/dRT4EGvr
- Message queues - https://lnkd.in/dvSsgAyn

𝗗𝗼𝗺𝗮𝗶𝗻-𝗗𝗿𝗶𝘃𝗲𝗻 𝗗𝗲𝘀𝗶𝗴𝗻 𝗜𝗻𝘁𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻

- Rich Domain model - https://lnkd.in/drbTK9_W
- Entities - https://lnkd.in/dQzuqzR6 
- Value objects - https://lnkd.in/d4iWcybq
- Aggregate root - https://lnkd.in/dxb6dx-y
- Domain validation - https://lnkd.in/dZMjb5_v
- Domain model tradeoffs - https://lnkd.in/d2_9fBSv
- Repository pattern - https://lnkd.in/dq-mst-P
- Specification pattern - https://lnkd.in/enP-8n9i
- Unit of work - https://lnkd.in/e668P6wK
- Smart Enums - https://lnkd.in/efq34FS7
- Snapshot pattern - https://lnkd.in/eubBfFk4
- Strongly typed IDs - https://lnkd.in/dpgZ4gBw
- Anemic Domain model - https://lnkd.in/dmrGQTY9
- DDD modeling - https://lnkd.in/dnvgNgfg
- DDD + EF mapping - https://lnkd.in/dmSXbxqt
- Incomplete aggregates - https://lnkd.in/dBDQhRNQ
- Double dispatch - https://lnkd.in/dK4jQT7g

𝗖𝗤𝗥𝗦

- CQRS Fundamentals - https://lnkd.in/dKYS87-6
- Validation /w Result - https://lnkd.in/dZuc-6MM
- Validation /w Exception - https://lnkd.in/dqh9ZcAD
- Read models - https://lnkd.in/dD5W3FDn
- UoW pipeline - https://lnkd.in/dzwg6Uad
- The "Truth" on CQRS - https://lnkd.in/dbpFQ-2f
- CQRS Query side - https://lnkd.in/dKfXaeNx
- Materialized views - https://lnkd.in/dmfjhMKR

Hope this is helpful!

If you liked this, you should join The .NET Weekly - my newsletter with 74,000+ engineers.

You'll get a complete Clean Architecture template for free when you sign up.

Join here → https://lnkd.in/ec6jnhfJ

Have an awesome day!

EF Core 10 finally gets LeftJoin and RightJoin.

I always had to google how to do a left join in LINQ. Not anymore!

Now with the new operators in Entity Framework Core 10 you finally get clear, simple joins that match what you mean.

Before: GroupJoin + DefaultIfEmpty

Now: LeftJoin

With the new LeftJoin method you write exactly that: “keep all from left, match right when available.” The intent is obvious, the code is shorter, and the translation to SQL is the same.

I wrote about all the details of the new LeftJoin and RightJoin methods in this article: https://lnkd.in/eNmPqtBq

In short: the new LeftJoin and RightJoin operators in EF Core 10 clean up the mess, make your intent crystal clear, reduce boilerplate, and give you better readable code.

Better late than never, I guess...

---
Sign up for the .NET Weekly with 74K+ other engineers, and get a free Clean Architecture template: https://lnkd.in/ew5Adz89

EF Core LeftJoin and RightJoin

What is RBAC (Role-Based Access Control)?

Here's how it can help with your authorization policies.

RBAC stands for Role-Based Access Control.

Here's how RBAC works:
- Roles are assigned a set of permissions
- Users are granted roles, and thus permissions
- Permissions decide what a user can or can't do

What's the benefit?

One problem I always had with roles was fine-grained authorization rules.

Roles are too broad for some policies I need to enforce.

This is where permissions come in.

I can define permissions for specific actions.

It's easy to allow other roles to access that action: I have to assign the permission to the role.

It's not a complicated idea. But it's a powerful authorization approach.

If you want to learn more about RBAC authorization and how to implement it, check out this article: https://lnkd.in/evk9tk9K

RBAC transforms authorization from a maintenance headache into a flexible, scalable system.

Start with permissions: Define what actions users can perform, not what roles they have.

---
Sign up for the .NET Weekly with 74K+ other engineers, and get a free Clean Architecture template: https://lnkd.in/eNZHSNQr

No alternative text description for this image

Want to get started with Event-Driven applications?

Event notifications are one of the simplest patterns to explore.

Domain events in DDD are a great example of this pattern.

Aggregates act as a consistency boundary in a domain. So if we need to change something outside the aggregate, we can publish a domain event.

It's a loosely coupled way for two aggregates to communicate.

An aggregate raises a domain event. Other aggregates can subscribe to this domain event and handle it accordingly.

Here's how you could implement this: https://lnkd.in/efekt2DQ

Domain events can help you build a loosely coupled system.

You can use them to separate the core domain logic from the side effects, which can be handled asynchronously.

---
Sign up for the .NET Weekly with 74K+ other engineers, and get a free Clean Architecture template: https://lnkd.in/eNZHSNQr

How do you add Health Checks in .NET?

- AddHealthChecks - introduces the required services
- MapHealthChecks - exposes a health check endpoint

The next thing you need to do is introduce health checks.

There are many HC libraries for popular databases, message brokers, etc.

If you want a complete guide, here's an article you will enjoy.

Learn more about Health Checks here: https://lnkd.in/eZpbteUs

Multiple EF Core DbContexts in a single application?

Here's when it makes sense to do this:

- Working with multiple databases
- Separating concerns
- Modular monolith
- Read replicas

I did this when implementing a modular monolith application.

Each module had a dedicated schema in the database and a separate DbContext in the code.

The surprising part?

How EF Core deals with database migrations and different schemas.

Here's a breakdown of how I solved this: https://lnkd.in/e6JWgpNv

Did you need to use multiple DbContexts with EF?

---
Sign up for the .NET Weekly with 74K+ other engineers, and get a free Clean Architecture template: https://lnkd.in/eDqzAKsP

6 things I do to set up my new .NET projects the right way

1. Enforce a consistent code style
2. Centralize build configuration
3. Centralize package management
4. Add static code analysis
5. Set up local orchestration
6. Automate builds with CI

I wrote a step-by-step guide on how to configure all this here: https://lnkd.in/eCpE6KM3

What else would you add to this project setup?

I already know a few people will say tests.

Definitely integration testing with something like Testcontainers.

---
Sign up for the .NET Weekly with 74K+ other engineers, and get a free Clean Architecture template: https://lnkd.in/ew5Adz89

6 tips for .NET Project setup

One small change = 400x FASTER query

Here's what I did to achieve this performance boost.

I was implementing cursor pagination with EF and Postgres.

But I need to make the query faster.

How do you make an SQL query faster?

Add an index, and you're good to go.

Right?

Not quite...

I created a composite index on the required columns to speed up the query.

BUT THIS MADE THE QUERY SLOWER!!!

This led me down a rabbit hole to figure out why the index wasn't used.

I knew about tuple comparison from before, and this solved the problem.

But I didn't know how to translate this into an EF Core query.

Luckily, the Postgres provider supports this with a custom function.

Here's everything you should know: https://lnkd.in/eD629U-B

---
Sign up for the .NET Weekly with 74K+ other engineers, and get a free Clean Architecture template: https://lnkd.in/e-XH7dM7

How I made my query 400x faster using EF and tuples

Do you know all 3 ways to define Middleware in ASP .NET Core?

Middleware allows you to introduce additional logic before or after executing an HTTP request.

Middleware is an excellent choice for solving cross-cutting concerns in your application.

You are already using many of the built-in middleware available in the framework.

I'm going to show you three approaches to define custom middleware:

- Request Delegates
- Convention based
- Factory based

Here's everything you need to know: https://lnkd.in/eHYAh7Pc

How do you prefer to define middleware in .NET?

Caching isn’t magic.

If your queries are slow or your algorithms are inefficient, caching won’t save you.

But once you’ve done the hard work:
- Optimized your database
- Fixed slow code paths
- Tuned your queries

Caching can make everything feel "instant".

I’ve seen APIs go from good to great just by caching the right data in the right place.

ASPNET Core gives you several ways to do that:
- IMemoryCache for in-memory caching
- IDistributedCache for shared, multi-instance apps

Each has its own strengths, and using them effectively is key to real performance gains. I wrote a guide that walks through the options, trade-offs, and gotchas, with code samples you can use right away.

Read it here: https://lnkd.in/ez9Dhn7M

And starting with .NET 9, there’s a new option: HybridCache.
It combines L1 and L2 caching, so you get the speed of in-memory cache plus the consistency of a distributed backend like Redis. It’s one of my favorite new additions because it solves real-world problems with minimal setup.

If you want to see how HybridCache works and when to use it in production, I covered that here: https://lnkd.in/eNY-BcBD

In the end, caching solves caching problems.

But don't forget that some problems, like bad design, inefficient queries, or missing indexes, can’t be solved with a cache.

---
Sign up for the .NET Weekly with 74K+ other engineers, and get a free Clean Architecture template: https://lnkd.in/eDqzAKsP

How to use caching in ASP.NET Core

Building a multi-tenant system?

EF Core has some great features you should know about:
- Dynamic connection strings
- Query filters for global tenant queries

You'll need a service to provide the TenantId for the current tenant. You can grab this value from a request header or JWT claim.

That TenantId will be used to filter data so each tenant only sees their own records. EF Core query filters make this easy to apply across your entire data model.

For connection-per-tenant setups, you can resolve the connection string at runtime. This gives you full isolation at the database level, great for larger tenants or stricter security needs.

Side effect: you'll only be able to use the DbContext as part of an HTTP request. Background jobs or integrations will need another way to resolve the tenant context.

If you're curious to learn more about what EF can offer for building multi-tenant applications, check out this article: https://lnkd.in/ekKkqr8S

I hope you now have a better understanding of how to build a multi-tenant system with EF Core.

I showed you the bare bones implementation, which you can improve to make it more robust and secure.

Building multi-tenant systems isn't easy, but when you understand the basic principles it shouldn't be too difficult either.

---
Sign up for the .NET Weekly with 74K+ other engineers, and get a free Clean Architecture template: https://lnkd.in/eNZHSNQr

How to build Multi-Tenant apps with EF Core

How do you create HttpClients in .NET?

The recommended approach is using the IHttpClientFactory.

You can use the IHttpClientFactory directly.

The downside is you'll have to configure the HttpClient every time.

If you want to get a pre-configured HttpClient, you can use named or typed clients.

Here's the right way to work with HttpClient in .NET: https://lnkd.in/eiRxYj-T

I showed you a few possible options for working with HttpClient.

But which one should you use and when?

I prefer working with a typed client, and I'm mindful of the fact that it's configured as a transient service.

---
Sign up for the .NET Weekly with 74K+ other engineers, and get a free Clean Architecture template: https://lnkd.in/eNZHSNQr

Most REST APIs fail not because of bad code, but because of bad design.

After building and reviewing dozens of APIs over the years, I’ve learned one thing: Consistency and pragmatism matter more than “perfect” architecture.

In my latest video, I share 8 pragmatic REST API design tips that I use in production. From consistent naming and correct status codes, to pagination, error responses, and hypermedia links, all shown in a real .NET example app.

Check it out: https://lnkd.in/enzqCKDs

If you’re designing APIs for real-world systems (not toy projects), this one’s for you.

I worked on an application that scaled to 1M+ active users.

It was powered by a single Azure SQL instance.

However, we would run into problems when a traffic spike happened.

Some queries would eat up the database resources.

So, here are the two things we did to improve performance:
- Cache aggressively
- Add a read replica

We used two-level caching on all application instances. First, we checked the in-memory cache, and in case of a cache miss, we checked if the data was available in Redis.

Sidenote: HybridCache makes this easy in newer .NET versions.

Caching significantly reduced the load on the database and allowed us to scale.

However, some queries took a long time to execute, and it didn't make much sense to cache the results.

So, we decided to use a read replica for these queries

Luckily, Azure makes the entire replication process easy to configure.

Here are 7 more ways you can scale your application: https://lnkd.in/eBbQ--wD

If there's one thing you take away from this post, it's scale when necessary.

If we did this at the start of the project, it would've only slowed us down.

--- 
Sign up for the .NET Weekly with 74K+ other engineers, and get a free Clean Architecture template: https://lnkd.in/ew5Adz89

Two ways to scale applications

What's wrong with the first code snippet?

The second example is 43x faster to insert 10,000 records.

But what causes such a huge performance difference?

If you understand how EF works under the hood, the answer should be obvious. 👇

Every call to SaveChanges means one round-trip to the database.

In the first example, inserting each record means one call to the database.

This quickly adds up...

Here's why it's important to use the right tool for the job: https://lnkd.in/eStH9yku

Sending unnecessary queries to the database is one of the biggest performance killers in enterprise applications.

---
Sign up for the .NET Weekly with 74K+ other engineers, and get a free Clean Architecture template: https://lnkd.in/eDqzAKsP

Does your application need input validation?

There's a 99% chance the answer is YES.

Don't reinvent the wheel - use FluentValidation.

FluentValidation gives you a simple API to build complex validation rules.

You can write rules to ensure values are:
- Not null
- Not empty
- Have a min/max length
- Are equal/not equal to some value
- Define your completely custom rules

It's easy to write asynchronous validation rules using the MustAsync method. Dependency injection also works as you'd expect.

Here's how you can use FluentValidation to build a global validation middleware in minutes: https://lnkd.in/eKa6XVrT

Have you used FluentValidation before?

---
Sign up for the .NET Weekly with 74K+ other engineers, and get a free Clean Architecture template: https://lnkd.in/e-XH7dM7

How to easily Validate DTOs in your .NET APIs

AI can write your code. But it can also ship your next security bug.

That’s the reality for anyone using Copilot, Cursor, or Gemini today.

Coding is easy. Reviewing, verifying, and securing it isn’t.

In my latest video, I show how SonarQube’s new MCP Server closes that gap.

It connects your AI-powered IDE directly with SonarQube Cloud or Server — so you can scan, fix, and validate code without ever leaving your editor.

✅ Run full static analysis through Cursor
✅ Catch vulnerabilities and maintainability issues instantly
✅ Automate code reviews with Sonar’s AI integration

It’s free, open-source, and runs in Docker.

Learn more here: https://lnkd.in/eY6MG3br

Once you see it in action, you’ll never ship AI-generated code without it again.

If your .NET app runs background jobs or distributed workers, you need a way to prevent duplicate execution.

Otherwise, two instances can pick up the same task: sending duplicate emails, charging twice, or overwriting data.

That’s where distributed locking comes in.

In my latest video, I show how to implement production-ready distributed locks in .NET using a single clean library.

You’ll see how to:
- Use Postgres advisory locks and Redis for distributed coordination
- Build a reusable locking abstraction for any .NET app
- Decide when it actually makes sense to use one

If you care about reliability and data integrity, this one’s worth your time.

Learn more: https://lnkd.in/eWfVWmHk

Every time I started a new project, I felt like I was solving the same setup problems from scratch.

I needed a solid starting point, something I could trust to get me from idea to code fast.

So I built a Clean Architecture template that covers all the basics.

And I shared it with a few friends, and they loved it.

So I decided to make it available for everyone.

Here's what's inside:
- Simple domain model, Domain Events pattern
- CQRS without any external dependencies
- Cross-cutting concerns (validation, logging)
- Authentication with JWT, user context
- Boilerplate for RBAC authorization
- Docker Compose or .NET Aspire
- Minimal APIs, health checks

Since the launch, it's been downloaded by more than 35,000+ developers.

You can get the template here: https://lnkd.in/erv9rFSH

taplio

Milan Jovanović's Linkedin Analytics

Milan Jovanović

Performance ScoreMilan Jovanović's LinkedIn Performance

What is Milan talking about?

Who is engaging with Milan

Milan Jovanović's Best Posts (last 30 days)

Ready to grow your LinkedIn presence?

taplio

.css-6ytdur{background-image:linear-gradient(284deg, rgba(39, 43, 72, 1) 0%, rgba(33, 47, 183, 1) 100%);color:transparent;-webkit-background-clip:text;background-clip:text;}Milan Jovanović's Linkedin Analytics

Milan Jovanović

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

What is Milan talking about?

Who is engaging with Milan

Milan Jovanović's Best Posts .css-1emoo84{font-size:var(--chakra-fontSizes-md);font-weight:400;color:var(--chakra-colors-gray-600);}(last 30 days)

Ready to grow your LinkedIn presence?

Milan Jovanović's Linkedin Analytics

Performance ScoreMilan Jovanović's LinkedIn Performance

Milan Jovanović's Best Posts (last 30 days)