DEV Community: Ravikant Vijayvargiya

Deconstructing our microservices, Part 1: The app crashed in production and what we did next

Ravikant Vijayvargiya — Thu, 11 Jun 2026 05:36:16 +0000

This API had been working fine in production for 2 years. The process was taking the expected time and resources, but boom. One day, one of our pods crashed.

Self-healing mechanisms were already in place to handle the situation; the system automatically redeployed the pod instance as configured.

But the question remains, Why?

The API was tested, working flawlessly with real production data from the last 2 years. So many customers were using it. Resource allocation seemed adequate until now.

So we checked the Application Insights on Azure for CPU, memory, and other resource usage. The pod crashed due to high memory usage. A customer had a very large file.

Now, let’s learn what this API does. We were working on a web application that handles various types of financial calculations. This particular API reads a file and imports its data into the system. The import process includes reading data from a file, processing data for various validations, including checking for a valid file, verifying mathematical constraints, and performing calculations on it before saving. Formatting the data in the required system formats and creating hierarchies that have foreign key references in the database. Some hierarchies go as deep as 12 levels. It sent the real-time status of the process using SignalR. A file can be a single CSV file or a zip file that contains CSV files. Data will be stored across 30+ tables in the SQL Server database. We had 1 GB of memory for a pod. After we got hold of similar data, we tested it on staging, and it was taking 3–4 days in an idle instance. It was also very long. The large file had 1.5 million rows.

Now we know the reason is high memory usage. What was the cause? Resources, code, database, or its query?

A large file processing was taking up to 1 GB of memory. If any other process uses a good chunk of memory, it implies less memory for our import process. So this one process was taking the whole pod down with it.
We were downloading the files into memory and reading data from them. The memory usage increased exponentially with the large files.
We were saving hierarchical data to create one row at a time, so we could have the parent ID to create the hierarchy. It was not a big issue with general files, but that was not the case with this specific file.

With these analyses, we decided to make a few changes.

Extracting the Import Microservice

Let’s move the import process out of the calculation service, so if it goes sideways, the whole calculation pod does not go down with it. To manage n number of pods, used KEDA (Kubernetes Event-driven Autoscaling). A new pod was created for a new import request. After the process was completed, the pod would scale in. The calculation service was publishing events to the Azure Service Bus topic, and KEDA was autoscaling up to the max n( 5 in our case) pods. If there were more than n requests, these requests were held in a message queue. KEDA also gives us the advantage of parallel processing.

Blob Stream

Instead of reading the data from a file/memory stream, read directly from the Azure Blob Storage using blob stream. This reduced the direct file content in the memory, thus improving performance. The pros of reading blob stream outweighed the cons of keeping a connection open to blob storage. The connection remained open for a very short duration, not for the whole process time, and we did not keep the file in the memory. Previously, we deleted the file after the end of the process. Now we were keeping the file data in data objects in code.

Code Optimization

We were saving the rows one by one because when the code was first written, we had limited exposure to the variety of the data we were going to have in the files. After 2 years of this process working, we had better business metadata to understand the scope better. We had three main hierarchy patterns to handle. In two cases, more than 99% of the data was in the last node of the hierarchy. And in the remaining one case, 99.5% of users never created a hierarchy. They were using only the top-most node. Now we were more comfortable using SQLBulkCopy to bulk save the data. We used a batch size to not overwhelm the database.

Let me point out one more thing that we were already doing. We were not doing this whole import process in a transaction because a transaction on this long process can lead to a deadlock in the database. We were maintaining a flag to mark the status of the process. Only when the status shows success is the data shown in the UI. User was getting a real-time update of the process via SignalR. If the process failed for any reason, we deleted the dirty data.

As you may guess, we also made other changes to accommodate our KEDA pattern. The import process logic was idempotent, so the server can safely process the same message twice without corrupting the SQL Server data

Post Optimization

Now our process was optimized. What took 3 to 4 days is now done in 3–4 hours. But one new issue arose with it, due to the now faster process, the client was flooded with SignalR. The UI froze. It was receiving more data than it could process and display. We were showing every single row status to the user, so we chose to display updates after every few thousand rows. Real-time to near real-time update.

Production crashes are painful, but they are also the best architectural forcing functions. Looking back, our 2-year-old API didn’t fail because it was poorly written; it failed because it hit a scaling wall. By re-architecting the solution, we learned a few invaluable lessons:

Isolate the Blast Radius: Never let a heavy background process share a fate with your core user-facing services. Use event-driven scaling (like KEDA) to let heavy lifters crash in peace without taking down the ship.

Stream, Don’t Swallow: When dealing with unpredictable file sizes, avoid memory buffering. Keep your Large Object Heap (LOH) clean by streaming data directly from cloud storage.

Manage Backpressure: True optimization doesn’t stop at the backend. If you make your data processing 10x faster, ensure your frontend delivery mechanisms (like SignalR) are throttled to handle the flood.

Have you ever had a seemingly stable API suddenly blow up after years in production? How did your team handle the scaling bottleneck? Let’s talk about it in the comments below!

[Boost]

Ravikant Vijayvargiya — Fri, 31 Oct 2025 07:00:41 +0000

Ravikant Vijayvargiya

Aug 30 '24

Microservices: Service-to-service invocation with Dapr, docker-compose, and .NET

#csharp #docker #dapr #beginners

7 min read

Discovering the Hidden Dependencies in Your DLLs

Ravikant Vijayvargiya — Wed, 26 Feb 2025 10:14:21 +0000

This cool application finds all the dependent DLLs of the provided DLL.

GitHub Repo:- https://github.com/lucasg/Dependencies

Download from here

Just unzip the folder, run DependenciesGui, and upload the DLL file to see the results.

Cool website to edit PDF

Ravikant Vijayvargiya — Sat, 25 Jan 2025 09:22:39 +0000

https://www.sejda.com/pdf-editor

Simple to use. You can easily add and remove content.

LLM Visualization

Ravikant Vijayvargiya — Thu, 16 Jan 2025 09:06:30 +0000

LLM Visualization: A 3D animated visualization of an LLM with a walkthrough.

This website demonstrates various LLM models, such as GPT-2(small), nano-GPT, and GPT -3.

https://bbycroft.net/llm

Remove Windows software completely

Ravikant Vijayvargiya — Thu, 05 Dec 2024 06:25:19 +0000

Windows uninstall/remove software feature is good but does not completely remove the software. For example, if you uninstall Chrome browser and install it again, you may find previous data.

Sometimes we want to wipe out a software and its data completely.
I find Revo Uninstaller very useful in this case. Its free version is sufficient for personal use.

The best part is that it creates a Windows restore point, so there is no fear of losing any other data.

Download link:- https://www.revouninstaller.com/revo-uninstaller-free-download/

Unit testing with xUnit: Introduction

Ravikant Vijayvargiya — Sun, 08 Sep 2024 11:59:30 +0000

Wolf Fact: That's how a pack of wolves sound

Xunit.net is a free, open-source, community-focused unit testing tool for the .NET Framework.

Let’s go. Please visit this link for the code.

Create a .NET console app ( for simplicity) and add an xUnit test project to the solution. Now, we have two projects in the solution — one for application logic and another for unit testing.

xUnit Test Project

Solution XUnitTesting hierarchy

We should always keep the application code and its tests in separate projects.

Application- This project has our application logic.
Application.Test- As the name indicates, this project has test cases for the application code.

I wrote a simple method to divide two numbers in Logics class.

The access modifier for the method must be public. The xUnit checks all methods in all public exported classes in the assembly.

Now we will test this method. We will write unit tests for this method in the UnitTests class.

Don’t forget to add the Application project reference to the Application.Test project.

Fact-

UnitTests.cs TestDivide()

[Fact]: Marks a test method
Assert: The assert class contains various static methods. These methods are utilized to evaluate the testing conditions. Example:- Assert.Equal(expected value, actual value), Assert.True(boolean condition)and many more. You can check all assert statements here.

We pass parameter values for the method and then compare the actual and expected values. In the TestDivide() method, we pass parameters as 4 and 2 for the numerator and denominator respectively.

We can run tests using Test Explorer.

Test Explorer

Our test case passed for the numerator 4 and denominator 2. It would fail for numerator 1 and denominator 3.

We need to improve this test’s coverage. We should specify the precision in the assert statement.

Assert.Equal(expected, actual, precision)

Precision: Verify up to digits after the decimal

There is a drawback to writing test cases like this. We have to create different test methods for various inputs.

Theory-

xUnit theory overcomes the above drawback.

TestDivideMultipleInputs

[Theory]: Marks a test method as being a data theory. A theory is a test case with multiple intakes.
[InlineData]: To provide data for theory.

For an InlineData row, the test method executes one time. So the method TestDivideMultipleInputs will be executed three times. We can provide input parameters and desired output for the divide method using InlineData.

Exception-

This testing tool does not address exceptions with the general assert statements. It uses Assert.Throws. It validates that the exact exception is thrown and not a derived exception type.

TestDivideByZero()

For a zero denominator, the code will throw a DivideByZeroException. The TestDivideByZero() test method validates it. You may try different types of exceptions to verify.

Any feedback would be greatly appreciated. Thank you.

Roadmap to becoming an ASP.NET Core developer

Ravikant Vijayvargiya — Fri, 06 Sep 2024 13:57:00 +0000

I found this cool roadmap to becoming an ASP.NET Core developer by Moien Tajik.

You can find the road map here.

Hopefully, He will maintain this repo but I am still adding my fork in case... here

Moien Tajik LinkedIn

What do you think about this roadmap?

All AI engines in one place

Ravikant Vijayvargiya — Thu, 05 Sep 2024 12:05:00 +0000

https://you.com/

You.com is an innovative search engine.

You.com supports a variety of advanced AI models, allowing users to choose from different options for their conversational and task-oriented needs. Here are some of the key models available:

OpenAI's GPT Models: You.com includes access to OpenAI's GPT-4 and GPT-4 Turbo models, which are known for their high performance in natural language understanding and generation tasks.
Anthropic's Claude Models: This includes Claude Instant, Claude 2, Claude 3 Opus, Claude 3 Sonnet, and Claude 3 Haiku. These models are designed to provide conversational capabilities and are tailored for various applications.
Google's Gemini Pro: This model is part of Google's AI offerings and is designed to enhance conversational AI experiences.
Zephyr: An uncensored model that provides a different approach to AI interactions.

You.com allows users to toggle between these models using a Custom Model Selector, enabling a flexible and tailored experience based on user preferences and specific tasks.

Disclaimer: The content of this post has been generated using You.com

Brave Browser: with built-in Ad-blocker

Ravikant Vijayvargiya — Wed, 04 Sep 2024 13:31:00 +0000

Brave Browser

Privacy and Ad-Blocker

Brave browser has an inbuilt Ad-Blocker so we don't need any extension. It's like YouTube Premium without YouTube Premium, for music and videos.

It also has a Brave shield that can be used for advanced controls like blocking fingerprints and blocking third-party cookies.

Brave shows trackers and ads blocked on a site, like 10 in the above image.

It also displays the total number of trackers blocked till now.

Background Image

Brave has beautiful background images created/captured by various contributors. It makes the browser less boring.

Brave has some awesome features in its mobile version.

Media " width="800" height="1433">

Settings -> Media

Background Play

We can play videos on a Mobile device even when we are not using the Brave browser or our phone screen is off.

Block YouTube shorts

It disables the Shorts feature on YouTube.

In-Memory Database with SQLite

Ravikant Vijayvargiya — Sun, 01 Sep 2024 07:19:08 +0000

Wolf Fact: With 200M+ olfactory cells housed in the nose, a wolf’s sense of smell is their most acute. By smell alone, wolves can locate prey, family members, or enemies. They can also tell if other wolves are nearby if they're male/female, etc.

Prerequisites: C#, Visual Studio, basic concepts of database, Web API

What is SQLite? How to install SQLite? How to create a database with it? Why do we need an in-memory DB? And how create it with SQLite?

SQLite: SQLite is a C-language library that provides a SQL database engine that is small, fast, self-contained, high-reliability, and full-featured. SQLite database files are commonly used as containers to transfer rich content between systems and as a long-term archival format for data. SQLite uses dynamic types for tables. It means you can store any value in any column, regardless of the data type.

Install: You can install SQLite from here. I am using Windows, so I used SQLite-tools-win32-x86–3380300.

For Windows

You should choose one based on your OS. You should see the following three files after extracting this zip.

Create a database:

Open command prompt(cmd)

To create a new database

sqlite3 DBName.db
To see a list of the existing databases

.databases

A database with the name localDB.db

What is an In-Memory Database: The data in a traditional database is stored on disk. When the data is needed, it’s called into the local system memory — or RAM — and then is processed by the CPU. Because it takes time to search for data that resides on disks, bottlenecks frequently occur.

In contrast, an in-memory database stores data directly in system memory, plugging directly into the high-speed, low-latency memory bus. It decreases data latency by reducing the time needed to analyze data. With an in-memory database, data is accessed much quicker, allowing you to analyze large volumes of complex data in real time.

When should you use it? An In-memory database uses RAM for storage, resulting in faster read-write operations. You should consider an in-memory database if

The target system has data to manage, but no persistent media.
The performance requirement simply cannot be met with a persistent database

There are a few common examples in which an in-memory database can be useful.

Caching: You can increase performance by using a small in-memory database( can lose data) with a large disk-based database( reliable).
Batch Write: You can perform a batch of read-write operations on the in-memory database. You can back up this database to a physical database after a predetermined period( like 10 mins) or a predeﬁned number of operations( like 5000 queries), as needed.

Now let’s write some code.

We have created a physical database “localDB.db”. Now we need to add a table to this. We can do this using a query or manually using the UI. I am using DB Browser for SQLite to perform operations on the database. DB Browser for SQLite (DB4S) is a high-quality, visual, open-source tool to create, design, and edit database files compatible with SQLite. You can download it from here.

After installing DB Browser, We should add the “localDB.db” file to this.

To add db file

To access existing DB

Now let’s create a new table in the localDB.

Create Table TableOne(Id INT, Value Text)

Table Schema

In-memory database with SQLite: We will create an in-memory database in three main steps.

Duplicate physical database to in-memory: Copy physical DB schema( like tables ) to in-memory.
Operations on the in-memory database: Read-write operation on the in-memory database.
Back up the in-memory DB to the physical DB: Update the real database with the current state of the in-memory database. It is quite quick.

The complete source code can be found here. Let’s get started now.

Create a Web API.

A simple Web API

Add Nuget package to it.

Microsoft.Data.Sqlite

Solution File Structure( I tried to keep things as simple as possible.)

File Structure

I mainly created three files. Let’s go over them one by one.

IDbHelpers: This interface contains method declarations for acquiring physical and in-memory DB connections.

IDbHelpers

DbHelpers: This class contains implementations for GetPhysicalDbConnection and GetInMemoryDbConnection methods.

DbHelpers

-> dbFilePath: Path to “localDB.db” file

-> GetPhysicalDbConnection(): I set the Data Source to dbfilePath with read-write permissions.

-> GetInMemoryDbConnection(): I set the Data Source to :memory: for in-memory database.

Don’t forget to open the DB connection.

HomeController: The addRow API endpoint is available in HomeController. I’ll insert a row into TableOne using an in-memory database connection.

I am using SqlCommand in this example. You may use other methods like dapper. If necessary, you can additionally add a transaction to this connection.

Now let’s test it.

Swagger

and DB status

TableOne Data

We can see data has been successfully inserted and backed up into the physical database.

Friendly Suggestion: If you face an error during code execution that the Database is locked. Try closing the DB Browser.

Any comments or suggestions would be greatly appreciated.

Microservices: Pub/Sub with Dapr, docker-compose, and .NET

Ravikant Vijayvargiya — Fri, 30 Aug 2024 16:19:09 +0000

Wolf Fact: Wolves and domestic dogs share about 99.8% of their DNA, making them closely related.

Prerequisites: C#, basic of Web API, Visual Studio, Docker Desktop

Publish and Subscribe Pattern:-

It defines brokers, publishers, and subscribers, and how they should interact to create a loosely coupled scalable system. The publisher forwards the content/messages to the broker. And the subscribers get these messages from the broker.

The Pub/Sub pattern can be implemented in a variety of ways. Ex.- The broker may push messages to subscribers or subscribers may have to read messages from the broker. Like this, every step’s process depends on implementation.

The broker determines the type of content that a subscriber will receive. The broker uses message filtering techniques for this. There are two mainstream methods.

Topic-based: It is a name for logical channels. A subscriber will receive all the messages published to a topic based on their subscription. The publisher is responsible for defining the topics.
Content-based: In this case, the subscriber classifies what type of content it will receive. So Subscriber is responsible for defining the constraints.

Pub/Sub pattern makes the application more scalable because publishers are not directly bound to subscribers and the broker deals with message delivery. So publishers don’t have to make any changes for a large number of subscribers. That’s the job of the broker.

Pub/Sub with Dapr:-

Dapr supports pub/sub pattern. In Dapr implementation:-

Publisher: It writes messages to an input channel and sends them to a topic, unaware of which application will receive them.
Subscriber: It subscribes to the topic and receives messages from an output channel, unaware of which service produced these messages.

An intermediary message broker copies each message from a publisher’s input channel to an output channel for all subscribers interested in that message. Dapr provides *a content-based routing *pattern( filtering technique).

Dapr Pub/Sub

The pub/sub API in Dapr:

Provides a platform-agnostic API to send and receive messages. Ex. Windows, Linux …
Offers at-least-once message delivery guarantee. Dapr considers a message successfully delivered once the subscriber processes the message and responds with a non-error response.
Integrates with various message brokers and queuing systems. Ex. Apache Kafka, AWS, Azure Service Bus, Redis streams, and many more. You can check the complete list here.

Default Values:

Message Routing: For message routing, Dapr uses the header value Content-Type as datacontenttype. Any message sent by an application to a topic using Dapr is automatically wrapped in a Cloud Events envelope.

Message Content: For message content, Dapr uses the header value Content-Type as text/plain.The developer can change the content type for the message based on requirements.

Dapr applications can subscribe to published topics via two methods that support the same features:

Declarative: Subscription is defined in an external file( YAML file).
programmatic. Subscription is defined in the user code.

So how does dapr pub/sub work?

The Dapr sidecar of the subscriber service calls the /dapr/subscribe endpoint.
The Dapr sidecar of the subscriber creates the requested subscriptions on the message broker.
The publisher sends a message at the /v1.0/publish/<pub-sub-name>/<topic> endpoint on the Dapr publisher’s sidecar.
The publisher sidecar publishes the message to the message broker.
The message broker sends a copy of the message to the subscriber’s sidecar.
The subscriber’s sidecar calls the corresponding endpoint on the subscriber service then the subscriber returns an HTTP response.

HTTP Response Code
204 Message delivered
403 Message forbidden by access controls
404 No pubsub name or topic given
500 Delivery failed
200 Success

Now Let’s write some code. I will continue with the code that I wrote in the previous article. The complete source code can be found here.

I am using the programmatic subscription approach, the subscription will be defined in the code. My Project ServiceOne will behave as a Publisher and ServiceTwo as a subscriber. I will use the Redis Stream component for the broker.

In both services, NuGet packages Dapr.Client and Dapr.AspNetCore is required.

Startup.cs:-

ServiceOne Startup.cs ( Publisher)

ServiceTwo Startup.cs ( Subscriber)

Add these methods to respective services.

UseCloudEvents(): Dapr uses Cloud event 1.0 for message routing( sending messages to topics and receiving responses from subscribers). So we need this method in both startups.
MapSubscribeHandler(): Map the endpoint that will respond to requests /dapr/subscribe from the Dapr runtime. So needs only in subscription service.

Note: If your service is behaving as both subscriber and publisher then you need to add both these methods to the startup.

2. ServiceOne IDaprClientHelper and DaprClientHelper:-

ServiceOne IDaprClientHelper

ServiceOne DaprClientHelper

This method is only required in ServiceOne (Publisher). PublishToTopicWithDaprClient method has so many concepts. Let’s understand them.

2.1. topicName: The name of the topic. It is a user-defined name.

2.2. data: Data that needs to be published on the topic.

2.3. daprClient: The Dapr client package allows interaction with other Dapr applications from a .NET application. The daprClient is an instance of DaprClientBuilder that would be used to call other dapr services.

2.4. PublishEventAsync: Publish an event to the specified topic.

2.5 pubsubname: It is the name of the pubsub component. This will be used by subscribers to subscribe to a topic. We will see it in the ServiceTwo controller.

3. ServiceOne IServiceTwoHelper and ServiceTwoHelper:-

IServiceTwoHelper

ServiceTwoHelper

PublishMessageTopic calls PublishToTopicWithDaprClient method. In this step, serviceOne( + sidecar) will write a message on the specified topic.

pubsubname: pubsub
topicName: publishmessage
data: Notice that data is passed as an object but not as a primitive data type.

4. HomeController:-

ServiceOne Controller Method PublishMessage

This controller method is used to publish the message to the topic.

ServiceTwo Controller Method PublishMessage

This controller method will receive the message from the broker/topic. Notice the header. The topic has two parameters.

First:- pubsubname. Which is pubsub.
Second:- topicName. Which is publishmessage

Both are the same as PublishToTopicWithDaprClient parameters.

Now let’s update the docker-compose file. I am using Redis streams. So I have added the below-mentioned lines to docker-compose.

Docker-compose.yaml

It defines that we need a service Redis on host port 6379 with any available hostname( I chose redisstate, you may choose based on your preference).

Hey, we have written a programmatic subscription for pubsub. Okk.

Also added Redis service to docker-compose file. Okk.

But how will our services know they need to use this Redis stream? hmmm.

Now let’s do this…

Do you remember the declaration of the component in the docker-compose sidecar?

This folder is used to define the components that can be used. We are going to use redis stream component.

Folder structure

Components Folder

Dapr keeps a YAML file in the components folder to identify the components that need to be used.

pubsub.yaml

This file defines that we are using a Redis component at port 6379. I am using dapr.io apiVersion V1 alpha1. The hostname and port number are the same as the docker-compose file.

Now the coding part is done. So let’s run the code.

>>> docker compose build

>>> docker compose up

With these two commands, our services will be up and running.

Call to Service One PublishMessage

It shows status code 200, Success. You can check the console of ServiceTwo to confirm that the message is published correctly( Because I have written it on the console in the ServiceTwo controller).

Docker Desktop (Two services, their sidecars, and Redis service is running)

Docker ServiceTwo Logs

Correctly Published.

So that’s how we can perform Pub/Sub operation with Dapr, docker-compose, and .NET.

Note: You can check out the complete code here. The first commit has docker-compose configurations, and the service-to-service invocation code. The second commit has an extra pub-sub configuration and the pub/sub code.

Any comments or suggestions would be greatly appreciated.