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!

Here are 5 underappreciated LINQ methods you should know:

- Zip
- Chunk
- OfType
- DistinctBy
- SelectMany

LINQ is full of gems that can make your code cleaner and more efficient.

Here are 5 more honorable mentions that didn't make the cut:

- SequenceEqual
- Aggregate
- GroupJoin
- ToLookup
- Intersect

P.S. Every Saturday morning, I send one practical tip to 57,000+ .NET engineers to help them grow their skills.

Join free here: https://bit.ly/4eHy3Hx

What's one LINQ method that you think deserves more love?

Milan Jovanović

Don't start with microservices. ❌

Even if you think your application will be big enough to justify it.

And here's why. Microservices come with a premium:

- Team coordination
- Dealing with failure
- Eventual consistency
- Automating deployments
- Managing multiple services
- Provisioning additional infrastructure

You don't need this complexity at the start of a new project.

Does this bring value to your users? Most likely, no.

If you can't manage a large monolith system, you won't do better with microservices.

Your team's experience plays a significant role in building successful microservices.

Here's a less risky strategy:

- Start with a Monolith
- Discover the service boundaries (bounded contexts)
- Then decide if you need to break them into microservices

Many other factors also play a role. I can't fit them all into one post.

But I hope I've given you some food for thought.

If you want to learn more about (Modular) monoliths, go here: https://lnkd.in/ekJvADUm

Here's a contrarian take if you're up for a good discussion.

Would you start a greenfield project with Microservices, and why?

MediatR is one of the best .NET libraries I ever worked with.

You'll end up reinventing the wheel if you roll your own.

You can use it to implement the CQRS pattern.

The CQRS pattern separates the writes and reads in the application.

This separation is mainly logical. Separate components handle each operation.

MediatR decouples the in-process sending of messages from handling messages.

You can extend MediatR's IRequest interface with a custom ICommand and IQuery abstraction.

This allows you to be explicit about commands and queries in your system.

A few benefits of using MediatR:

- Organize your code around use cases (high cohesion)
- Easily implement cross-cutting concerns
- API endpoints become very thin
- Use cases are highly testable

If you want to learn more about CQRS with MediatR, I wrote a detailed guide.

You can read it here: https://lnkd.in/eUhi8KkG

The one drawback of MediatR I have to highlight is indirection.

But this is a tradeoff I accept to get the other benefits.

What's your stance on using MediaR?

---
Do you want to simplify your development process? Grab my free Clean Architecture template here: https://bit.ly/3UAgssW

You should never return null collections in C#.

There are better solutions.

What problem does returning null collections cause?

Let's stop for a moment to consider how we use collections.

You typically want to iterate over a collection in a loop.

But if your method returns null collections, this can lead to potential errors.

Now, your code must handle the null case and check for null before iterating the collection.

Adding a null check every time can make the code more verbose.

It's even worse if the calling code doesn't handle the null case.

Things will blow up at runtime.

You could argue that a null value expresses some intent.

But I still prefer avoiding null in my code as much as possible.

A best practice I like to follow is returning:

- a new List()
- Enumerable.Empty
- Array.Empty
- C# 12 collection expressions → []

With empty collections, your code can iterate over the collection without worrying about null checks.

P.S. Every Saturday morning, I send one practical tip to 58,000+ .NET engineers to help them grow their skills.

Join free here: https://bit.ly/4dR9sP4

What do you think about returning null collections (or nulls in general)?

---
Do you want to simplify your development process? Grab my free Clean Architecture template here: https://bit.ly/3UAgssW

One rule I follow in microservices systems:

All message consumers must be idempotent.

What happens when a message is re-sent in a distributed system?

This could happen for several reasons.

- We retry the publish because we didn't receive an ACK
- The broker can retry delivering a message due to a network failure

The worst-case scenario is that we process the message twice. Unfortunately, this also means we can apply side effects more than once.

There are two ways how you can solve this:

1. Make your operation idempotent. Some operations are naturally idempotent, so duplicate messages aren't a problem.

2. However, some operations are not naturally idempotent. In this case, you have to implement idempotency manually. You can use the Idempotent Consumer pattern to solve this.

Here's how the Idempotent Consumer works:

- Was the message already processed?
- If yes, it's a duplicate, and there's nothing to do
- If not, we handle the message and store the message ID

You also need to run this operation inside a transaction to ensure consistency. If concurrency is an issue, you could also consider locking to prevent race conditions.

Here's how you could implement idempotent consumers: https://lnkd.in/eeTy86CJ

Have you used the Idempotent Consumer pattern before?

Another option to consider is having an Inbox on the consumer side.

Onion architecture vs. Clean architecture

What is the difference between these approaches?

One of them makes you cry!

(okay, jokes aside)

Both architectures revolve around the same idea:

- The direction of dependencies is toward the center
- The core contains the domain entities and business rules
- The core should be independent of any external concerns

The main idea here is controlling coupling.

Our domain entities and business rules are at the center of the system.

They don't depend on anything, which is valuable because it makes them stable.

Things around the Domain can change, which shouldn't affect the domain or business rules.

Remember, coupling is the degree of interdependence between our modules and components.

Both Clean and Onion architecture strive to achieve the same goals.

- We have the Domain in both
- Clean architecture has use cases
- Onion architecture has domain and application services
- On the very edges, we have infrastructure concerns

So what's the difference?

Any differences fade when it's time to implement this architecture in a project.

Another architectural driver you should consider is cohesion.

Cohesion refers to the degree to which the elements within a module belong together and work together to achieve a single, well-defined purpose.

This is the main driver behind Vertical Slice Architecture.

If you want to learn more about VSA, start here: https://lnkd.in/eG_JAevy

---
Do you want to simplify your development process? Grab my free Clean Architecture template here: https://bit.ly/4fxT73m

A must-know pattern for distributed systems:

The Saga pattern.

The Saga pattern allows you to manage long-running processes involving multiple services.

At its core, the Saga pattern coordinates data flow and actions between services.

This coordination can take two forms:

1. 𝗖𝗵𝗼𝗿𝗲𝗼𝗴𝗿𝗮𝗽𝗵𝘆 - where each service independently communicates with others to achieve a common goal

2. 𝗢𝗿𝗰𝗵𝗲𝘀𝘁𝗿𝗮𝘁𝗶𝗼𝗻 - where a central authority coordinates the services' actions.

Sagas are practical for implementing a long-lived process in a distributed system.

Each business process is represented by a local transaction.  We publish a message to trigger the next step in the Saga.

What happens if some step in the Saga fails?

This is often overlooked, as most engineers write code for the happy path.

However, you should consider how to handle an error in each step of the Saga.

The best way to handle an error will depend on what's best for the business.

Here's how to implement the Saga pattern in .NET with RabbitMQ: https://lnkd.in/eg3DwRt9

What is your experience with the Saga pattern?

What is the easiest way to generate PDF reports?

HTML-to-PDF conversion is my first choice.

I use IronPDF in most commercial projects.

Looking for a free option? Check out Puppeteer Sharp.

But the core idea is what matters here.

With an HTML template, you have more control over formatting.

You can use modern CSS to style the HTML markup.

Here's the high-level implementation:

- MVC views and the Razor syntax
- Render dynamic HTML content
- Pass HTML to PDF renderer

I've used this approach with MVC views on a few projects with great results.

Want to see how to implement flexible PDF reporting?

Here's a simple guide: https://lnkd.in/eeytR-v6

How do you implement PDF reporting?

---
Do you want to simplify your development process? Grab my free Clean Architecture template here: https://bit.ly/3C4uHQf

Controllers vs Minimal APIs - Which one is better?

Here's how to decide which one is better for YOU.

Some people claim controllers are better.

Others swear that Minimal APIs are better.

The truth is somewhere in the middle.

The problem with controllers is that they become complex with many endpoints. I've seen a handful of projects with controllers having thousands of lines of code. Each endpoint could introduce its required services. So, the constructor grows to accommodate this.

But is this an inherent problem of controllers? Not really.

It's a technical problem that you should know how to solve.

However, there is an argument to make about "falling into the pit of success".

Minimal APIs take a different approach. Endpoints declare the specific services they need. We don't share any dependencies between them. Better cohesion.

Minimal APIs are also more performant.

But should you move from controllers to Minimal APIs? Not really.

Choose the approach that aligns better with your team's experience and preferences.

I use Minimal APIs because I find them simpler.

They also let me implement "package by feature" with ease.

Read this article for a fresh perspective: https://lnkd.in/eR-Hf9B3

Which one would you choose?

---
Do you want to simplify your development process? Grab my free Clean Architecture template here: https://bit.ly/3C4uHQf

Want to simplify your Microservices communication?

Here's how service discovery can help.

Microservices can come and go, scale up or down, and even move around within your infrastructure, which poses a problem.

How do your services find and communicate with each other reliably?

Hardcoding IP addresses is a recipe for fragility.

Enter service discovery.

Service discovery allows you to refer to external services using logical names. It provides a centralized location for services to register themselves (IP + port). Clients then query the service registry to find the service's physical address. This is a common pattern in large-scale distributed systems.

Here's what the service discovery flow looks like:

1. The service will register itself with the service registry

2. The client must query the service registry to get the physical address

3. The client sends the request to the service using the resolved physical address

Here's how you can implement Service Discovery in .NET using Consul: https://lnkd.in/e8QrVRrv

Are you looking for a lightweight solution?

There's a .NET library that implements a light version of service discovery. Instead of a service registry, you provide the physical addresses through app settings.

Which solution for service discovery would you choose?

Why should you care about rate limiting in .NET?

Rate limiting can make your APIs more robust and secure.

It's a technique to limit the number of requests to a server or an API.

This reduces the load on the server and improves overall reliability.

There are 4 rate limit algorithms available out of the box:

1. Fixed window

2. Sliding window

3. Token bucket

4. Concurrency

However, these are global rate limiters and are rarely practical.

In reality, you want to rate limit specific users or IP addresses.

You can do all this in .NET with the rate limiting middleware and partitioner.

How will rate limiting work if you scale out?

The short answer is - it won't.

You'll have to define the rate limit policies on a reverse proxy like YARP.

Or you can implement a Redis backplane to store rate limit data.

Here are 3 advanced rate limiting use cases in .NET: https://lnkd.in/ev2Y-fEH

As an API consumer, you must also factor in any existing rate limits.

How would you reduce the number of requests to prevent reaching the limit?

5 things I add to new .NET projects to set them up for success:

1. Coding conventions - .editorconfig

2. Static code analysis - SonarAnalyzer

3. Observability - Serilog, OpenTelemetry

4. Docker-compose - local development story
*Aspire is also an excellent option here

5. CI/CD pipeline for build & test (bare minimum)

Everything is easier with this initial setup.

The team has a consistent development experience.

And we can focus on providing business value to customers.

Here's how you can set up OpenTelemetry in .NET: https://lnkd.in/e9sC7sDZ

What else would you add?

---
Do you want to simplify your development process? Grab my free Clean Architecture template here: https://bit.ly/3UAgssW

Two types of message-driven communication you need to know:

1. Orchestration
2. Choreography

Working with distributed systems is both fun and challenging at the same time.

One of those challenges is designing effective communication between services.

More centralization or less centralization?

More coupling or less coupling?

More control or less control?

These are only a few questions you need to answer. But there are many more.

Orchestration is a centralized approach to Microservices communication. One service acts as the orchestrator and coordinates the communication between services.

Choreography is a decentralized communication approach that uses event-driven communication instead of commands.

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

Which communication approach would you use and why?

Don't make this integration testing mistake.

Using in-memory databases is a waste of time.

Frankly, you can't even call this integration testing.

I've seen some developers do this with the EF in-memory provider.

That's not even a real database (did you read the docs?).

So, what value can those "integration" tests have? Zero, if you ask me.

Instead, spin up an actual database using Docker.

You can connect to this database from your tests.

And now you're writing proper integration tests.

This is even easier in .NET with the Testcontainers library.

Here's how to get started: https://lnkd.in/evvvGF7A

Once you get the hang of it, you'll realize how powerful this testing approach is.

Integration tests become simple to write, as the setup is minimal.

graphical user interface, text, chat or text message

What is an API Gateway?

Here's the simplest explanation I like to use.

An API gateway is the "front door" to your backend services and APIs.

It handles client requests and routes them to the appropriate destinations.

The key characteristics of an API gateway are:

- Request routing and composition
- Authentication and Authorization
- Load balancing
- Rate limiting
- Monitoring
- Caching

An important role of API gateways is security.

You can implement authentication at the API gateway level.

Only authenticated requests can reach the backend services.

YARP is a popular reverse proxy library in .NET. It integrates with the built-in authentication and authorization components. You can use the familiar auth mechanism using claims and policies.

Here's how you can implement API gateway auth in .NET: https://lnkd.in/enSn_XQ5

You can even relax the security policies if your APIs run in an internal network (VPC).

For example, in an Azure Container Apps environment, your APIs run in Azure Container Apps.

You can easily hide the Container Apps from the outside.

How do you implement API gateways?

---
Do you want to simplify your development process? Grab my free Clean Architecture template here: https://bit.ly/3UAgssW

No alternative text description for this image

How can you generate API tests using AI?

Imagine if it were this simple:

• Send an API request request
• The AI takes care of the rest

It turns out you can do this from your favorite API client.

Postman has an integrated AI assistant called Postbot that can do many cool things.

Here's a 4-step guide to generate API tests with Postbot:

- Send a request to your API from Postman
- Open up Postbot and ask it to add tests for this request
- Voila, you've got a bunch of tests, and you can easily add more
- You can write custom prompts to customize the test cases further

Your test cases will execute the next time you send an API request.

You can check if some test has failed. This could mean you have a bug or a regression.

Ready to learn more about API testing?

Here's an excellent resource: https://lnkd.in/ec2a8_H3

I scaled my Outbox processor to 2B+ messages per day.

Here's what I did to get this blazing performance.

Implementing the Outbox pattern is just the first step.

The real challenge? Scaling it to handle massive message volumes.

The first thing I optimized is the query for fetching unprocessed messages.

I added a covered index. Now, the query planner produces an execution plan that does an index-only scan.

Then, I optimized message publishing to publish them in batches.

And then it was time for the most fun part.

I scaled out my Outbox processor with parallel processing.

The tricky part here is controlling concurrency.

Postgres solves this like it's a joke with FOR UPDATE SKIP LOCKED.

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

It's a long read, but it's worth it, I promise.

How would you scale this further?

Here are 8 tips to make your code clean:

✅ Use result objects
✅ Merge if statements
✅ Early return principle
✅ Magic string -> Enum
✅ Prefer custom exceptions
✅ Use LINQ for conciseness
✅ Magic number -> Constant
✅ Bool expression -> Method

Good developers can spot code smells with one glance.

If you want to master clean code, start here: https://lnkd.in/exVdw9hA

---
Do you want to simplify your development process? Grab my free Clean Architecture template here: https://bit.ly/4fxT73m

What is a webhook, and how is it different from polling? 

Here's an example to help you understand it.

You want your application to automatically do something when something happens in another system.

That's where webhooks come in.

Webhooks allow one system to send a message to another whenever a specific event occurs. For example, your shipment service might receive a webhook from a carrier that delivers packages.

Here's the basic flow:

1) Service A exposes a webhook

2) Service B subscribes to the webhook from Service A

3) Service A writes down the subscription

4) The event occurs in Service A

5) Service A sends the webhook request to Service B

There are many ways that webhooks can be helpful.

I implemented a webhook in a text-to-speech API.

The application exposes an endpoint to upload a text file, and you can also pass in a webhook URL.

An AI model will process the text file in the background and convert it into an audio file.

When the audio file is complete, the application will trigger the webhook.

The client can then download the audio file or do something else.

The critical component here is the HttpClient.

Here's the right way to use it in .NET: https://lnkd.in/eg-feTvJ

When was the last time you integrated with a webhook?

One of my favorite HttpClient features?

DelegatingHandler.

They're like middleware for outgoing HTTP requests.

A common use case for HTTP message handlers is authentication.

It's a simple way to obtain an access token before sending the request.

For example, the GitHub API uses a Personal Access Token issued to a user.

So, I have to fetch the access token from a secure source and set the Auth header.

Want to learn more about Delegating Handlers?

Here's an in-depth guide: https://lnkd.in/eQBn29fc

If you think about it, you can use it for any cross-cutting concern.

- Logging
- Auditing
- Caching
- Retries

How do you solve cross-cutting concerns when sending HTTP requests?

---
Do you want to simplify your development process? Grab my free Clean Architecture template here: https://bit.ly/4fxT73m

Taplio

Milan Jovanović's Linkedin Analytics

Who is engaging with Milan

's Best Posts (last 30 days)

Want to drive more opportunities from LinkedIn?

Taplio

.css-1jgreyo{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

Who is engaging with Milan

's Best Posts .css-qqfgvy{font-size:var(--chakra-fontSizes-md);}(last 30 days)

Want to drive more opportunities from LinkedIn?

Milan Jovanović's Linkedin Analytics

's Best Posts (last 30 days)