Shardul Kavar's Blog

Zero Trust Architecture in Backend Systems

Tue, 13 Oct 2026 03:30:00 GMT

Zero Trust Architecture in Backend Systems

The traditional network security model assumes that everything inside your private network (VPC) is safe. Modern cloud engineering has rendered this obsolete.

Zero Trust operates on a strict "never trust, always verify" principle. Even if a request originates from an internal microservice, it must be fully authenticated and authorized.
Implement mutual TLS (mTLS) between your internal services so they can cryptographically verify each other's identities before exchanging data.
Limit blast radius by adhering to the principle of least privilege. A background worker handling emails should not have read access to your users' password hashes.

Understanding Reverse Proxies

Fri, 09 Oct 2026 03:30:00 GMT

Understanding Reverse Proxies

Never expose a backend Node.js, Python, or Go application directly to the internet on port 80 or 443.

A reverse proxy acts as an intermediary, sitting at the edge of your network to intercept user requests before they hit your application logic.
It handles heavy lifting like SSL termination, gzip compression, and static file serving, freeing up your application to focus purely on executing business logic.
Tools like Nginx and Traefik are built in C and Go to handle thousands of concurrent connections efficiently, providing a critical layer of defense against malicious traffic.

Load Balancing Basics for Backend Developers

Wed, 07 Oct 2026 03:30:00 GMT

Load Balancing Basics for Backend Developers

A single server can only handle so much traffic before CPU and memory limits cause requests to queue and eventually drop.

Load balancers sit in front of your server pool and distribute incoming traffic evenly using algorithms like Round Robin or Least Connections.
They provide vital health checks. If a server in your cluster crashes, the load balancer automatically stops routing traffic to it, ensuring users never see a 502 Bad Gateway error.
Modern infrastructure relies on Layer 7 load balancing to route traffic based on HTTP headers or URL paths, enabling sophisticated microservice architectures.

Designing Reliable Webhooks

Mon, 05 Oct 2026 03:30:00 GMT

Designing Reliable Webhooks

When your application needs to notify external services about an event, webhooks are the industry standard. However, firing off an HTTP request and forgetting about it is a recipe for disaster.

Implement an exponential backoff retry strategy. If the receiving server is down, your system should automatically attempt to resend the payload at increasing intervals.
Always sign your webhook payloads using an HMAC secret. This allows the receiver to cryptographically verify that the request originated from your servers and hasn't been tampered with.
Maintain an audit log of all outbound webhooks, including request and response payloads, to simplify debugging when third-party integrations fail.

Safely Managing Database Migrations

Sat, 03 Oct 2026 03:30:00 GMT

Safely Managing Database Migrations

Altering a live production database schema is one of the most stressful tasks for a backend engineer. A locked table can instantly take down your API.

Always decouple schema changes from application deployments. Add new columns in one deployment, update the code to write to them in the next, and only drop the old columns weeks later.
Tools like Prisma, Liquibase, or simple SQL migration scripts ensure your database changes are version-controlled and reproducible across environments.
For large tables, avoid locking operations. Use tools like gh-ost or PostgreSQL's CONCURRENTLY index builds to migrate data seamlessly in the background.

Real-Time Backend Communication with WebSockets

Thu, 01 Oct 2026 03:30:00 GMT

Real-Time Backend Communication with WebSockets

Traditional HTTP requests are inherently unidirectional: the client asks, and the server answers. Building live features like chat requires a persistent connection.

WebSockets provide a full-duplex communication channel over a single TCP connection, allowing the server to push updates to the client instantly.
Scaling WebSockets requires careful architecture. Unlike stateless HTTP requests, maintaining thousands of open WebSocket connections consumes significant server memory.
Utilizing tools like Redis Pub/Sub helps synchronize WebSocket messages across multiple server instances, ensuring users receive updates regardless of which node they connect to.

GraphQL vs REST: Choosing the Right API Paradigm

Tue, 29 Sep 2026 03:30:00 GMT

GraphQL vs REST: Choosing the Right API Paradigm

Choosing between GraphQL and REST often dictates how your entire frontend and backend communicate for the lifecycle of a project.

REST is the battle-tested standard. It utilizes HTTP methods and caching natively, making it highly predictable and easy to scale using edge CDNs.
GraphQL solves the over-fetching problem by allowing the client to request exactly the data it needs in a single query.
I recommend sticking with REST for simple CRUD applications, but adopting GraphQL when building complex, data-heavy dashboards where minimizing network requests is critical.

Introduction to Event-Driven Architecture

Sun, 20 Sep 2026 03:30:00 GMT

Introduction to Event-Driven Architecture

Traditional monolithic applications often rely on synchronous communication, where one service must wait for another to finish before moving on.

The Problem with Synchronous: If a user registers, forcing the API to wait while a welcome email sends creates a terrible user experience and risks request timeouts.
Message Queues: By introducing a message queue (like RabbitMQ or AWS SQS), the API simply fires an "UserRegistered" event and immediately responds to the user. A separate background worker picks up the event later to send the email.
Decoupling Systems: This architecture completely isolates failure domains. If the email provider's API goes down, the core application continues running normally, and the queued emails simply wait until the service recovers.

Advanced Caching Strategies for Backend APIs

Fri, 18 Sep 2026 03:30:00 GMT

Advanced Caching Strategies for Backend APIs

Database queries are usually the slowest part of any backend operation, making a robust caching strategy essential for scaling.

In-Memory Caching: Using tools like Redis or Memcached allows you to store frequently accessed data in RAM, bypassing the disk completely for microsecond response times.
Cache Invalidation: The hardest part of caching is knowing when to clear it. Utilizing time-to-live (TTL) alongside event-driven invalidation ensures users do not see wildly outdated information.
Stale-While-Revalidate: This pattern is a game-changer for API gateways. It serves the slightly stale cached data to the user instantly, while silently triggering a background fetch to update the cache for the next request.

Modern Authentication Patterns

Wed, 16 Sep 2026 03:30:00 GMT

Modern Authentication Patterns

Authentication is the most critical part of any backend system. Rolling your own crypto is a notoriously bad idea, but understanding how tokens flow through your app is essential.

JWTs vs Sessions: JSON Web Tokens (JWTs) are excellent for stateless APIs, but they are incredibly difficult to invalidate before they expire. Server-side sessions offer better control but require database lookups on every request.
Storage Security: Never store access tokens in localStorage. They are highly vulnerable to Cross-Site Scripting (XSS) attacks. Always use HttpOnly, Secure cookies to store sensitive tokens so they cannot be read by frontend JavaScript.
OAuth 2.0: Delegating auth to providers like Google or GitHub not only reduces the risk of managing passwords but drastically improves user conversion rates by removing friction.

Building Resilient REST APIs

Mon, 14 Sep 2026 03:30:00 GMT

Building Resilient REST APIs

Creating an API is easy, but building one that survives edge cases, traffic spikes, and bad data requires defensive engineering.

Rate Limiting: Never trust the client. Implement strict rate limiting at the edge to protect your backend infrastructure from DDoS attacks or accidental infinite loops on the frontend.
Idempotency: Designing your POST and PUT requests to be idempotent guarantees that if a client accidentally sends the same payment or creation request twice due to network lag, the backend only processes it once.
Graceful Degradation: If a third-party microservice your API relies on goes down, your entire API shouldn't crash. Use timeouts, circuit breakers, and fallback cache layers to keep the core system running.

Connecting Heavy Databases to Static Sites

Sat, 12 Sep 2026 03:30:00 GMT

Connecting Heavy Databases to Static Sites

Static sites are incredibly fast, but eventually, you need to handle dynamic user data. The challenge is securely connecting a static frontend to a persistent relational database without exposing your credentials.

The most secure pattern is to abstract your database behind a dedicated API layer or serverless function. Your static site only ever talks to this API, never directly to the database.
Connection pooling is absolutely essential. Because serverless environments can spin up thousands of instances instantly, they can quickly overwhelm a traditional PostgreSQL or MySQL connection limit.
Utilizing modern tools like Prisma or Drizzle ORM alongside proxy connection poolers ensures your backend remains resilient even during massive traffic spikes.

Serverless vs. Edge: Where Should Your Backend Live?

Thu, 10 Sep 2026 03:30:00 GMT

Serverless vs. Edge: Where Should Your Backend Live?

As the line between frontend and backend blurs, deciding where your compute actually runs is critical for latency and performance.

Traditional serverless functions (like AWS Lambda) typically run in a single, centralized region. This is great for heavy database processing but can introduce cold starts and latency for users far from that data center.
Edge computing pushes those serverless functions to Content Delivery Network (CDN) nodes globally. Your logic executes mere milliseconds away from the user, making it ideal for authentication checks, localized data fetching, and A/B testing.
When building modern decoupled architectures, I prefer routing heavy database mutations to traditional serverless endpoints while keeping middleware and auth logic strictly on the Edge.

Why Netlify is Perfect for Static Sites

Tue, 08 Sep 2026 03:30:00 GMT

Why Netlify is Perfect for Static Sites

Hosting a static site has never been easier, and Netlify remains my top choice for seamless deployments.

The integration with GitHub is flawless, automatically triggering builds whenever new code is pushed to the main branch.
Netlify's Edge infrastructure ensures that compiled static assets are served instantly to users across the globe.
Features like custom build hooks allow developers to orchestrate complex, decoupled publishing architectures effortlessly.

Markdown vs MDX for Tech Blogs

Sun, 06 Sep 2026 03:30:00 GMT

Markdown vs MDX for Tech Blogs

When building a developer blog, choosing how you write your content is just as important as how you render it.

Standard Markdown is highly portable, lightweight, and ensures your writing remains platform-agnostic for years to come.
MDX takes this a step further by allowing you to embed interactive UI components directly inside your text.
I currently rely on standard Markdown for simplicity, but Astro's content collections make it incredibly easy to upgrade to MDX if I ever need interactive charts or custom code blocks.

Seamless Navigation with Astro View Transitions

Fri, 04 Sep 2026 03:30:00 GMT

Seamless Navigation with Astro View Transitions

One of the biggest historical drawbacks of standard Multi-Page Applications (MPAs) was the clunky, white-screen flash during page navigation.

Astro's View Transitions API solves this natively by swapping out the DOM seamlessly without requiring a heavy JavaScript framework.
By adding a single <ViewTransitions /> tag to the <head> of my base layout, my static blog instantly gained app-like, fluid page loads.
It preserves state across pages and allows for beautiful custom animations between routes with minimal configuration.

Mastering Image Optimization in Astro

Wed, 02 Sep 2026 03:30:00 GMT

Mastering Image Optimization in Astro

Image optimization can often be the trickiest part of building a genuinely fast static site, as large assets easily bottleneck your performance scores.

Astro makes handling these assets incredibly seamless out of the box, especially when you commit to using modern, highly compressed formats.
By switching my blog's cover images to WebP, I drastically reduced my overall page weight without sacrificing any visual fidelity.
Storing the .webp files right alongside the markdown files keeps the repository beautifully organized and ready for Netlify to deploy.

Automating My Astro Blog with GitHub Actions

Mon, 31 Aug 2026 03:30:00 GMT

Automating My Astro Blog with GitHub Actions

Building a static site does not mean you have to give up modern CMS features like scheduled publishing.

By decoupling my content repository from my portfolio presentation, I created a highly flexible system:

GitHub Actions handles the daily cron schedule to check for due posts.
A lightweight Node script manages the publication state without modifying my actual writing.
Netlify automatically fetches the private repository and deploys the updated content.

The Magic of Content Loaders

Astro's Content Loader API made it trivial to pull markdown files from outside the standard source directory. This means my code and my writing can live in entirely different repositories, keeping my workspace clean and focused.

I am excited to keep writing and tweaking this setup!

Hello Astro: Getting Started with Modern Static Sites

Tue, 25 Aug 2026 00:00:00 GMT

Hello Astro: Getting Started with Modern Static Sites

Welcome to my first post on this blog! In this article, we'll explore why Astro has become one of the most popular web frameworks for content-driven sites like blogs, documentation, and portfolios.

Why Astro?

Zero JS by Default: Astro renders HTML on the server and strips away unnecessary JavaScript unless you explicitly opt in with island architecture.
Content Collections: Built-in type safety and schema validation for Markdown and MDX content.
Framework Agnostic: Mix and match React, Vue, Svelte, or vanilla web components seamlessly.

---
// Component Script (Server-only)
const greeting = "Hello, World!";
---
<!-- Component Template -->
<div>
  <h1>{greeting}</h1>
</div>

Island Architecture

Astro pioneered Component Islands (Astro Islands). An island is an interactive UI component on an otherwise static page of HTML:

---
import InteractiveCounter from '../components/Counter';
---
<!-- This component hydrates on the client when visible -->
<InteractiveCounter client:visible />

What's Next?

Stay tuned for upcoming deep dives into custom themes, SEO optimization, and automated scheduled publishing workflows!