“I can’t do everything myself anymore.”

That’s usually when database sharding enters the conversation.

Don’t worry — it’s not scary. Let’s break it down simply.

So… what is database sharding?

Database sharding is the practice of splitting a large database into smaller, independent databases, called shards.

Each shard:

• Stores only part of the data

• Has the same structure as the others

• Can live on a different server

Instead of one massive database doing all the work, multiple smaller databases share the load.

A real-world analogy 📚

Imagine a library with one giant book that everyone wants to read at the same time.

Chaos, right?

Now imagine:

• The book is split into multiple volumes

• Each volume is placed on a different shelf

• People go directly to the volume they need

That’s sharding.

How data is split

To shard data, we choose something called a shard key — a value that decides where the data lives.

Common examples:

• user_id

• customer_id

• tenant_id

Example:

• Users with IDs 1–1,000,000 → Shard A

• Users with IDs 1,000,001–2,000,000 → Shard B

The app knows exactly which shard to talk to.

Common sharding strategies

1. Range-based sharding

Data is split by ranges.

Easy to understand, but risky if one range gets more traffic.

2. Hash-based sharding

A hash function spreads data evenly across shards.

Great balance, but harder to change later.

3. Directory-based sharding

A lookup table tells you which shard owns which data.

Flexible, but adds another moving part.

When should you actually use sharding?

Short answer: not early.

Long answer: use sharding when…

✅ Your database is huge (hundreds of GBs or more)
✅ Writes are very high
✅ A single database server is maxed out
✅ Indexing, caching, and replicas are no longer enough
✅ You need to scale horizontally, not vertically

Sharding is common in:

• Social networks

• E-commerce platforms

• SaaS products with many tenants

• Event/logging systems

When you should NOT shard (yet)

❌ Early-stage startups
❌ Small or medium traffic apps
❌ If adding indexes solves the problem
❌ If caching (Redis) solves the problem
❌ If read replicas solve the problem

Golden rule:
Sharding is a scaling strategy, not a starting point.

image credit to: www.geeksforgeeks.org

The good, the bad, and the honest truth

👍 What sharding gives you

• Massive scalability

• Faster queries (smaller datasets)

• Higher write throughput

• Better fault isolation

👎 What it costs you

• More complex application logic

• Cross-shard joins are painful

• Transactions get complicated

• Re-sharding is hard

• Operations become more complex

Sharding is powerful — but it’s not free.

Sharding vs Replication

• Replication → Same data, multiple copies (great for reads)

• Sharding → Different data, split across nodes (great for scale)

Most systems do:
👉 Replication first
👉 Sharding later

Final thoughts

Database sharding is one of those tools you don’t need often —
but when you do need it, nothing else will save you.

If you design your system with sharding in mind (even if you don’t use it yet), your future self will thank you 🙌

So, what is polymorphism?

It’s the ability of different classes to respond to the same method call in their own unique way. In simpler terms: one interface, many implementations.

Here’s how I use polymorphism in .NET to write smarter, cleaner code:

🔹 Method Overriding: I use virtual and override to let derived classes customize behavior while preserving a common interface.

🔹 Interfaces & Abstract Classes: I define contracts that multiple classes can implement differently—perfect for plug-and-play architecture.

🔹 Dependency Injection: I inject abstractions and swap implementations without changing the calling code. Flexibility at its finest.

🔹 Design Patterns: Polymorphism powers patterns like Strategy, Command, and State—making my codebase adaptable and future-proof.

💡 Whether I’m building APIs, services, or UI components, polymorphism helps me write code that’s not just functional—but dynamic, scalable, and easy to evolve.

Let’s stop rewriting logic. Let’s start designing for change.

DotNet #Polymorphism #OOP #CSharp #CleanCode #SoftwareArchitecture #DesignPatterns #Interfaces #FullStackDeveloper #CodeQuality #SOLIDPrinciples #DevCommunity #TechLeadership

So, what’s the magic of interfaces?

An interface defines a contract. It tells your classes what they must do, without dictating how they should do it. This separation of concerns is the key to flexibility, testability, and maintainability.

Here’s how I use interfaces in .NET to build better software:

🔹 Loose Coupling: I design systems where components depend on abstractions, not concrete implementations. This makes my code easier to swap, extend, and refactor.

🔹 Dependency Injection: I inject services via interfaces, making my applications modular and test-friendly.

🔹 Testability: With interfaces, mocking dependencies becomes effortless—unit testing is no longer a headache.

🔹 Design Patterns: Interfaces power patterns like Strategy, Repository, and Adapter—making architecture elegant and future-proof.

💡 Whether I’m building APIs, microservices, or enterprise apps, interfaces help me write code that’s clean, consistent, and built to evolve.

Let’s architect with intention. Let’s code with clarity.

DotNet #Interfaces #OOP #CSharp #SoftwareArchitecture #DependencyInjection #DesignPatterns #CleanCode #FullStackDeveloper #CodeQuality #SOLIDPrinciples #DevCommunity #TechLeadership

So, what’s the magic of interfaces?

An interface defines a contract. It tells your classes what they must do, without dictating how they should do it. This separation of concerns is the key to flexibility, testability, and maintainability.

Here’s how I use interfaces in .NET to build better software:

🔹 Loose Coupling: I design systems where components depend on abstractions, not concrete implementations. This makes my code easier to swap, extend, and refactor.

🔹 Dependency Injection: I inject services via interfaces, making my applications modular and test-friendly.

🔹 Testability: With interfaces, mocking dependencies becomes effortless—unit testing is no longer a headache.

🔹 Design Patterns: Interfaces power patterns like Strategy, Repository, and Adapter—making architecture elegant and future-proof.

💡 Whether I’m building APIs, microservices, or enterprise apps, interfaces help me write code that’s clean, consistent, and built to evolve.

Let’s architect with intention. Let’s code with clarity.

DotNet #Interfaces #OOP #CSharp #SoftwareArchitecture #DependencyInjection #DesignPatterns #CleanCode #FullStackDeveloper #CodeQuality #SOLIDPrinciples #DevCommunity #TechLeadership

So what is abstraction?

It’s about exposing only the essential features of an object while hiding the unnecessary details. Think of it as designing a clean API—users know what it does, not how it does it.

Here’s how I use abstraction in .NET to write smarter code:

🔹 Interfaces: I define contracts that classes must follow, making my code loosely coupled and easy to extend.

🔹 Abstract classes: I use them to share common behavior across related classes while leaving room for customization.

🔹 Dependency Injection: By programming to abstractions, I inject services via interfaces, making my apps more testable and modular.

🔹 Design Patterns: Abstraction powers patterns like Strategy, Factory, and Adapter—making my architecture clean and future-proof.

💡 Whether I’m building APIs, designing services, or architecting enterprise apps, abstraction helps me focus on what the code should do—not how it does it.

Let’s build systems that are elegant, extensible, and easy to reason about.

DotNet #Abstraction #OOP #CSharp #SoftwareArchitecture #FullStackDeveloper #CleanCode #Interfaces #DesignPatterns #DependencyInjection #SOLIDPrinciples #CodeQuality #TechLeadership #DevCommunity

So what is abstraction?

It’s about exposing only the essential features of an object while hiding the unnecessary details. Think of it as designing a clean API—users know what it does, not how it does it.

Here’s how I use abstraction in .NET to write smarter code:

🔹 Interfaces: I define contracts that classes must follow, making my code loosely coupled and easy to extend.

🔹 Abstract classes: I use them to share common behavior across related classes while leaving room for customization.

🔹 Dependency Injection: By programming to abstractions, I inject services via interfaces, making my apps more testable and modular.

🔹 Design Patterns: Abstraction powers patterns like Strategy, Factory, and Adapter—making my architecture clean and future-proof.

💡 Whether I’m building APIs, designing services, or architecting enterprise apps, abstraction helps me focus on what the code should do—not how it does it.

Let’s build systems that are elegant, extensible, and easy to reason about.

DotNet #Abstraction #OOP #CSharp #SoftwareArchitecture #FullStackDeveloper #CleanCode #Interfaces #DesignPatterns #DependencyInjection #SOLIDPrinciples #CodeQuality #TechLeadership #DevCommunity

So, what is encapsulation?

It’s the art of bundling data and behavior into a single unit—your class—while hiding the internal implementation details. Think of it as giving your objects a protective shell, exposing only what’s necessary and safeguarding the rest.

Here’s how I use encapsulation in .NET to build better software:

✅ Private fields + Public properties: I keep class variables private and expose them through controlled accessors (get/set) to enforce validation and business rules.

✅ Access modifiers: private, protected, internal, and public—these aren’t just keywords; they’re your toolkit for defining boundaries and responsibilities.

✅ Immutability: By using readonly fields and immutable types, I ensure data integrity and thread safety.

✅ Encapsulated logic: Business rules live inside the class, not scattered across the codebase. This keeps my code DRY, testable, and easier to refactor.

💡 Whether I’m designing a domain model in a DDD architecture or building a reusable component in Blazor, encapsulation helps me write code that’s robust, secure, and future-ready.

Let’s not just write code that works—let’s write code that lasts.

DotNet #Encapsulation #OOP #CSharp #CleanCode #SoftwareDesign #FullStackDeveloper #CodeQuality #SOLIDPrinciples #DevBestPractices #Blazor #DotNetDeveloper #TechLeadership #CodingWisdom

Here’s how I leverage OOP in .NET to write better code:

🔹 Encapsulation: By wrapping data and behavior into cohesive classes, I keep my code modular and secure. Think private fields with public properties—clean, controlled, and future-proof.

🔹 Abstraction: Interfaces and abstract classes in .NET help me define clear contracts. This keeps my code flexible and focused on what it should do, not how it does it.

🔹 Inheritance: I use inheritance to promote code reuse and reduce redundancy. Base classes in .NET allow me to define common behavior once and extend it across multiple modules.

🔹 Polymorphism: With method overriding and interface implementation, I can write code that’s adaptable and open to extension—perfect for evolving business needs.

💡 Whether it’s building APIs with clean architecture, designing reusable components in Blazor, or crafting domain-driven designs, OOP principles are the backbone of my .NET development strategy.

Let’s write code that’s not just functional—but elegant, testable, and built to last.

DotNet #OOP #CSharp #SoftwareArchitecture #FullStackDeveloper #CleanCode #Encapsulation #Abstraction #Inheritance #Polymorphism #Blazor #SOLIDPrinciples #CodeQuality #DevCommunity #TechLeadership

🥇 .NET 10: The Powerhouse Framework

The most performant and secure .NET yet. With native AOT (Ahead-of-Time) compilation improvements, your apps start faster and run leaner than ever.

🌐 Blazor United: One UI to Rule Them All

Blazor WebAssembly and Blazor Server are now unified, letting you build full-stack web apps with C#—no JavaScript required. It’s a game-changer for productivity and maintainability.

🧠 AI-First Development with ML.NET

Integrate machine learning models directly into your apps using ML.NET. From intelligent recommendations to real-time predictions, AI is now a first-class citizen in .NET.

📦 Modular Monoliths Over Microservices

2025 is the year of the modular monolith. Simplify your architecture, reduce complexity, and scale smarter—not harder.

📱 Cross-Platform Nirvana with .NET MAUI

Build once, deploy everywhere—iOS, Android, macOS, and Windows. .NET MAUI is now more stable, feature-rich, and developer-friendly than ever.

☁️ Cloud-Native with Azure Integration

From serverless functions to containerized microservices, .NET 10 is deeply integrated with Azure, making cloud-native development seamless.

🛠️ Visual Studio 2026: Developer Delight

The new IDE brings AI-assisted coding, real-time collaboration, and performance profiling that feels like magic.

💡 Full-stack devs, it’s time to level up. Embrace the future with .NET 10 and build apps that are faster, smarter, and truly cross-platform.

DotNet10 #FullStackDeveloper #Blazor #MLNET #DotNetMAUI #Azure #VisualStudio2026 #AIinDev #ModularMonolith #CloudNative #DevCommunity #TechTrends2025 #CSharp #DotNetCore #SoftwareDevelopment

Understanding the differences between various types of elements in WPF is essential for effective application development. Let’s break down each type and their use cases:

Window (WPF):

A Window in WPF represents a top-level window that typically hosts the main user interface of your application.

It can contain any other WPF controls and elements.

Windows are typically used to create the main UI of an application, such as the main application window or dialog boxes.

Page (WPF):

A Page in WPF represents a navigable content page, often used in navigation-based applications.

It can contain other WPF controls and elements.

Pages are commonly used in navigation-based applications such as those using the Frame control or NavigationWindow.

User Control (WPF):

A User Control is a reusable composite control that you create by combining other existing controls and UI elements.

It encapsulates a piece of UI functionality that you can reuse in multiple places within your application.

User controls are used to encapsulate and modularize UI elements and logic, promoting code reusability and maintainability.

Custom Control (WPF):

A Custom Control is a control you create by deriving from an existing WPF control or from the Control base class.

It allows you to create new controls with custom appearance and behavior.

Custom controls are used when you need a specialized control that is not provided by the standard WPF controls, or when you need to extend the behavior of an existing control.

Flow Document (WPF):

A Flow Document in WPF represents a document that flows and adjusts its content dynamically based on available space.

It provides advanced text formatting and layout capabilities suitable for displaying rich text documents.

Flow documents are commonly used in applications that need to display formatted text with complex layouts, such as text editors or document viewers.

Page Function (WPF):

A Page Function in WPF represents a specialized type of page that supports a wizard-like user interface with multiple steps or pages.

It allows you to define a sequence of pages that guide the user through a specific task or process.

Page functions are used in applications that require multi-step user interactions, such as setup wizards or configuration processes.

Splash Screen (WPF):

A Splash Screen in WPF is a visual element that is displayed briefly when the application starts, providing feedback to the user that the application is loading.

It typically displays a logo, progress bar, or other visual elements to indicate that the application is initializing.

Splash screens are used to enhance the user experience by providing feedback during application startup, especially for applications with longer load times.

Resource Dictionary (WPF):

A Resource Dictionary in WPF is a XAML file that contains shared resources such as styles, templates, and other reusable elements.

It allows you to define resources once and reuse them across multiple elements or controls within your application.

Resource dictionaries are used to centralize and manage styles, themes, and other resources, promoting consistency and maintainability in your UI design.

Thanks for reading. Please like and share

Happy Coding!

In this article I am basically going to create a simple react web app then I will help to deploy on azure static web application and at last will map our custom domain with it.

Before digging more into action, Lets have

1.       Azure account.

- If not, please go here and open it free. https://azure.microsoft.com/en-in/free/

2.       GitHub account

    - If not, please click here to sign up for free. https://github.com/

3.       A domain name.

- There is multiple domain provider in market you can go there to have yours.

- For example, I have from https://www.godaddy.com/en-in.

1. Steps

We will follow these steps to hit our target.

1.       A web application.

2.       Pushing source code of application on GitHub.

3.       Azure static web application configuration.

4.       Domain DNS mapping.

5.       Live application demo.

System I have in use.

Nodejs 18x

OS: Window 10

Code editor: VS Code

1. Web application

Steps to create a static web app.

1. Open a command line.

   1. I’m creating a application with name ‘hellowordl’

      1. npx create-react-app helloworld

      2. cd helloworld

      3. npm run start.


   Open the browser and go to https://localhost:3000

   

   Perfect you have running reactjs web application.

2. Source Code to GitHub

Now go to https://github.com/login to create new private repository.

Click on “Create Repository”

Push your changes into repo with below commands.

git remote add origin https://github.com/yourusername/helloworld.git.

git add.

git commit –m “init”

git branch -M main

git push -u origin main

3. Azure Static Web App Configuration

Now open your Azure portal

https://portal.azure.com

1.       Search for static web app and select it.

2. Click on “Create” Fill the details.

3. In deployment details

   Make sure to choose the right things in options.

   

   Review+Create

   Wait to complete the deployment. Once deployment done go to overview page.

4. You may notice info alert on top of the view.  ‘Github Action runs’ on click on that to see the status of github action.

Once done to go overview of azure static web application and click on the unique generated url.

Click on the url to see your running application.

Enjoy your application hosted on Azure as static web and running on cloud

4. Domain Mapping

Go to your DNS provider in my case it is GoDaddy.

https://dcc.godaddy.com/

Go to your domain DNS management page.

1. If your domain does not start with www

2. Find forward option in panel and forward your domain to start with www.

a. Example: your domain is yourdomain.com need to forward www.yourdomain.com.

Next go to Azure static web overview search for custom domain

Click on “Add” option on top. Select ‘Custom domain on other DNS’ → Type your domain -> Click next for verification.

Next screen will show a CNAME.

Add this CNAME to your DNS provider(godaddy). Add and wait till validation.

It’s validated now.

Select www.yourdomain.in and click on Set Default option on top.

Now type www.yourdomain.in in any browser

Cheers, you have done it!!

Thank you reading my blog. If you like it please subscribe and share.

Happy Coding!

Subscribe now