Katt Risen

Build The Keyword

Find online business ideas that will bring you customers on auto-pilot

Product of the day #1 on Product Hunt

Founder

nocode-exits.com (acquired)

Join 10,000+ subscribers for free and learn how these makers have started and grown profitable or acquired projects made with NoCode.

Product of the day #3 on Product Hunt

100DaysOfNoCode

Practicioner in Residence

Creator in Residence

No-Code Guru (Acquired)

A wise tool advisor for beginner No-Code makers

Maker

MY STORY

+ Before 2022
Reading business books and listening to startup podcasts. Always lurking, never doing.
Always full of ideas and dreams, but never the skills to act on it.

+ February 2022
Learned about No-Code and joined the 100 Days of No-Code Bootcamp

+ April 2022
Launched my first side project made with No-Code on Product Hunt

+ June 2022
Started doing No-Code freelance gigs
Gave my first No-Code workshop

+ August 2022
First side project got acquired

+ Augustus 2022
Started www.nocode-exits.com

+ 2023
Quit my job to go full time No-Code. Freelancing and building a portfolio of tiny products made with No-Code

+ 2024
Started www.buildthekeyword.com

Join 5,000+ subscribers for free and learn how these makers have started and grown profitable or acquired projects made with NoCode.

Product of the day #3 on Product Hunt

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ć

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

undefined undefined

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.

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

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

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

Don’t start with microservices. ❌

Even if you think you'll need them later.

Microservices come with a heavy tax:
• More moving parts to coordinate
• More ways for things to break
• Complicated deployments
• Higher infrastructure costs
• Dealing with out-of-sync data

None of this helps you ship faster early on.

If you can’t build a clean monolith, microservices won’t save you. They’ll just multiply your mess.

Do this instead:
1️⃣ Start with a modular monolith.
2️⃣ Let clear boundaries emerge naturally.
3️⃣ Split into separate services later (only if you have to).

Your architecture should evolve with your product, not the other way around.

Want to see how this works in practice?

Read my full guide on building modular monoliths in .NET here: https://lnkd.in/drka9JfN

Would you start a brand new project with microservices today?

Let me know why or why not below! 👇

---

P.S. If you want to master the Modular Monolith Architecture, start here: https://lnkd.in/dx3KBMxN

𝗛𝗼𝘄 𝗩𝗲𝗰𝘁𝗼𝗿 𝗦𝗲𝗮𝗿𝗰𝗵 𝗪𝗼𝗿𝗸𝘀 (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

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

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

𝗬𝗔𝗥𝗣 𝘃𝘀. 𝗡𝗚𝗜𝗡𝗫: 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

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

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

𝗛𝗲𝗮𝗹𝘁𝗵 𝗖𝗵𝗲𝗰𝗸𝘀 𝗶𝗻 𝗔𝗦𝗣 .𝗡𝗘𝗧 𝗖𝗼𝗿𝗲

As systems grow more complex, you need fast feedback on what’s working and what’s not.

Want to keep your app reliable and resilient?

That’s where health checks help.

They monitor the health of key parts like:

- APIs
- Databases
- Caches
- External services

.NET has built-in support for health checks, plus many ready-to-use NuGet packages.

✅ Expose a health check endpoint
✅ Integrate with cloud monitoring
✅ Auto-replace or reroute from unhealthy instances
✅ Wait for dependent services to come online

If you’re using Aspire, health checks are part of its core.

Ready to get started?

Read this: https://lnkd.in/dsJ9A_2s

Aspire uses health checks to implement waiting for dependent services.

For example, your API won't start until the database and cache are ready.

---

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

I write a lot of .NET code. Most of that work is building APIs every day.

But jumping between my code editor and my testing tools has always slowed me down.

That just changed. The 𝗡𝗲𝘄 𝗣𝗼𝘀𝘁𝗺𝗮𝗻 is a complete overhaul.

It brings your APIs right to where you work.

Think about the last time you built a new API endpoint. You write the code. Then you open a different app to test it. Then you manually update the docs. It is a slow, broken process.

Now, you do it all in one spot. You can even run the exact same tests locally that you use in your CI pipeline. There are no more "it works on my machine" bugs. You catch issues before you even push your code.

In the New Postman, your API work is now native to your Git repo. Your specs, tests, and collections live right inside your code. This means you can version them across branches and pull requests. They act just like your regular app code.

You can easily switch between working on your API and your code. You get a built-in file editor and terminal right there. You do not have to switch tools to run your tests locally.

The AI tools are also amazing. The AI model picker lets you choose what fits best. I love that you can use Claude Opus 4.6. It is incredibly powerful for coding.

If you build APIs every day, you have to see this.

Check out the NEW version of Postman here: https://fandf.co/4tYUShK

A huge thank you to Postman for sponsoring this post!

taplio

The Battle

Katt Risen

Milan Jovanović

Followers

Posts

Engagements

Likes

Performance ScoreMilan Jovanović's LinkedIn Performance

Ready to grow your LinkedIn presence?

taplio

The Battle

Katt Risen

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

Ready to grow your LinkedIn presence?

Performance ScoreMilan Jovanović's LinkedIn Performance