<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Md Ashik&apos;s Blog</title>
    <link>https://blog.mdashikjs.com</link>
    <description>Notes on backend engineering, system design, and the practical tradeoffs behind shipping software that holds up in production.</description>
    <language>en-us</language>
    <lastBuildDate>Fri, 17 Apr 2026 00:00:00 GMT</lastBuildDate>
    <atom:link href="https://blog.mdashikjs.com/feed.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>The Module Pattern in Modern JavaScript: What Still Matters</title>
      <link>https://blog.mdashikjs.com/blog/module-pattern-modern-javascript</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/module-pattern-modern-javascript</guid>
      <description>ES modules made the old IIFE module pattern obsolete — but the thinking behind it is still the thing that separates a tidy codebase from a tangled one. Here is what I keep from it.</description>
      <pubDate>Fri, 17 Apr 2026 00:00:00 GMT</pubDate>
      <category>Frontend</category>
    </item>
    <item>
      <title>The Observer Pattern Is Everywhere in JavaScript — Once You See It</title>
      <link>https://blog.mdashikjs.com/blog/observer-pattern-javascript-practical</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/observer-pattern-javascript-practical</guid>
      <description>EventEmitter, DOM events, React state, Redux subscriptions, RxJS — it is all one pattern wearing different hats. Understanding it once makes every one of them easier.</description>
      <pubDate>Thu, 16 Apr 2026 00:00:00 GMT</pubDate>
      <category>Frontend</category>
    </item>
    <item>
      <title>Factory Functions: When `new` Feels Wrong</title>
      <link>https://blog.mdashikjs.com/blog/factory-pattern-clean-object-creation</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/factory-pattern-clean-object-creation</guid>
      <description>Classes and `new` are fine until you need to return different shapes, delay construction, or validate inputs before committing. Factory functions handle all three without ceremony.</description>
      <pubDate>Wed, 15 Apr 2026 00:00:00 GMT</pubDate>
      <category>Backend</category>
    </item>
    <item>
      <title>Singletons Felt Clever Until I Had to Test Them</title>
      <link>https://blog.mdashikjs.com/blog/singleton-vs-dependency-injection</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/singleton-vs-dependency-injection</guid>
      <description>Exporting a shared instance is fast to write and fast to regret. Dependency injection costs a few extra lines and pays them back every time you write a test.</description>
      <pubDate>Tue, 14 Apr 2026 00:00:00 GMT</pubDate>
      <category>Backend</category>
    </item>
    <item>
      <title>Strategy Pattern in the Wild: Swapping Payment Providers Without Touching Callers</title>
      <link>https://blog.mdashikjs.com/blog/strategy-pattern-payment-providers</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/strategy-pattern-payment-providers</guid>
      <description>We started with Stripe. Then legal needed a regional provider for one market. Without the strategy pattern this would have been a three-week rewrite. With it, it was a 200-line file and a switch in config.</description>
      <pubDate>Mon, 13 Apr 2026 00:00:00 GMT</pubDate>
      <category>Backend</category>
    </item>
    <item>
      <title>Pure Functions Changed How I Write Production JavaScript</title>
      <link>https://blog.mdashikjs.com/blog/pure-functions-javascript-production</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/pure-functions-javascript-production</guid>
      <description>A pure function does not reach outside itself, does not remember, does not surprise. It sounds austere until you have to refactor 2000 lines of side-effecty code at 2am.</description>
      <pubDate>Sun, 12 Apr 2026 00:00:00 GMT</pubDate>
      <category>Frontend</category>
    </item>
    <item>
      <title>Immutability in JavaScript: Beyond Object.freeze</title>
      <link>https://blog.mdashikjs.com/blog/immutability-javascript-beyond-freeze</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/immutability-javascript-beyond-freeze</guid>
      <description>`Object.freeze` is shallow, silent on failure, and barely used in practice. The real story of immutability in JavaScript is about discipline, tooling, and picking the right primitive for the problem.</description>
      <pubDate>Sat, 11 Apr 2026 00:00:00 GMT</pubDate>
      <category>Frontend</category>
    </item>
    <item>
      <title>Breaking a Monolith: NestJS Microservices with RabbitMQ</title>
      <link>https://blog.mdashikjs.com/blog/nestjs-microservices-rabbitmq</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/nestjs-microservices-rabbitmq</guid>
      <description>Our monolith handled everything from auth to billing. When deploy times hit 12 minutes and one bad merge took down the whole system, we started extracting services. Here is how we did it without rewriting from scratch.</description>
      <pubDate>Fri, 10 Apr 2026 00:00:00 GMT</pubDate>
      <category>Backend</category>
    </item>
    <item>
      <title>Currying and Partial Application: Boring Name, Useful Tool</title>
      <link>https://blog.mdashikjs.com/blog/currying-partial-application-practical</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/currying-partial-application-practical</guid>
      <description>I used to roll my eyes at currying. It felt like FP showing off. Then I started using it for configured loggers, middleware, and event handlers, and it quietly became part of my toolkit.</description>
      <pubDate>Thu, 09 Apr 2026 00:00:00 GMT</pubDate>
      <category>Frontend</category>
    </item>
    <item>
      <title>Function Composition Is the Refactor I Reach for First</title>
      <link>https://blog.mdashikjs.com/blog/function-composition-over-inheritance</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/function-composition-over-inheritance</guid>
      <description>Inheritance felt natural in Java class. In JavaScript it is almost always the wrong tool. Small functions plus `pipe` solve the same problems with less ceremony and more flexibility.</description>
      <pubDate>Wed, 08 Apr 2026 00:00:00 GMT</pubDate>
      <category>Frontend</category>
    </item>
    <item>
      <title>What Claude Opus 4.7 with 1M Context Actually Changes in Production</title>
      <link>https://blog.mdashikjs.com/blog/claude-opus-4-7-1m-context-production</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/claude-opus-4-7-1m-context-production</guid>
      <description>A million-token context window is a different tool, not a bigger version of the old one. Here is what it unlocked for us and where we still keep prompts short.</description>
      <pubDate>Tue, 07 Apr 2026 00:00:00 GMT</pubDate>
      <category>AI</category>
    </item>
    <item>
      <title>Designing Claude Skills: The Mental Model That Finally Clicked</title>
      <link>https://blog.mdashikjs.com/blog/designing-claude-skills-clicked</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/designing-claude-skills-clicked</guid>
      <description>I spent a week writing a Claude skill that nobody triggered. The fix was not more instructions — it was understanding that a skill is a folder with a contract, not a prompt with a description.</description>
      <pubDate>Mon, 06 Apr 2026 00:00:00 GMT</pubDate>
      <category>AI</category>
    </item>
    <item>
      <title>Docker Multi-Stage Builds for Node.js: From 1.2GB to 140MB</title>
      <link>https://blog.mdashikjs.com/blog/docker-multi-stage-builds-node</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/docker-multi-stage-builds-node</guid>
      <description>Our production Docker image was 1.2GB. Build times were painful, deploys were slow, and the attack surface was enormous. Multi-stage builds fixed all three problems.</description>
      <pubDate>Sun, 05 Apr 2026 00:00:00 GMT</pubDate>
      <category>DevOps</category>
    </item>
    <item>
      <title>Claude Code Hooks: How I Automated the Boring Parts of My Dev Loop</title>
      <link>https://blog.mdashikjs.com/blog/claude-code-hooks-dev-loop</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/claude-code-hooks-dev-loop</guid>
      <description>Hooks turn Claude Code from a chat tool into a deterministic part of my workflow. Auto-format after edits, block secret commits, and run the right test suite automatically — configured once in settings.json.</description>
      <pubDate>Sat, 04 Apr 2026 00:00:00 GMT</pubDate>
      <category>AI</category>
    </item>
    <item>
      <title>Writing Prompts That Get Real Development Work Done</title>
      <link>https://blog.mdashikjs.com/blog/effective-prompts-claude-dev-work</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/effective-prompts-claude-dev-work</guid>
      <description>Most bad results I get from Claude are not model problems. They are prompt problems. Here is what changed for me when I stopped writing instructions and started writing briefings.</description>
      <pubDate>Fri, 03 Apr 2026 00:00:00 GMT</pubDate>
      <category>AI</category>
    </item>
    <item>
      <title>How Prompt Caching Cut Our Claude API Bill by 75%</title>
      <link>https://blog.mdashikjs.com/blog/claude-prompt-caching-cut-costs</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/claude-prompt-caching-cut-costs</guid>
      <description>Our agent runs a 40k-token system prompt on every request. Without caching, that was the whole bill. With cache breakpoints in the right places, the cost became dominated by the actual variable content.</description>
      <pubDate>Thu, 02 Apr 2026 00:00:00 GMT</pubDate>
      <category>AI</category>
    </item>
    <item>
      <title>System Design Interview: Designing a URL Shortener, Step by Step</title>
      <link>https://blog.mdashikjs.com/blog/system-design-url-shortener-walkthrough</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/system-design-url-shortener-walkthrough</guid>
      <description>This is the canonical warm-up question, and it is still the one I see candidates botch most often. Here is the full 45-minute walkthrough the way I would deliver it today.</description>
      <pubDate>Wed, 01 Apr 2026 00:00:00 GMT</pubDate>
      <category>System Design</category>
    </item>
    <item>
      <title>System Design Interview: Rate Limiting at Scale</title>
      <link>https://blog.mdashikjs.com/blog/system-design-rate-limiting-at-scale</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/system-design-rate-limiting-at-scale</guid>
      <description>Rate limiting is a classic follow-up question that exposes whether you really understand distributed systems. The answer is not &apos;use Redis&apos; — it is picking the right algorithm and owning the failure modes.</description>
      <pubDate>Mon, 30 Mar 2026 00:00:00 GMT</pubDate>
      <category>System Design</category>
    </item>
    <item>
      <title>System Design Interview: Designing Twitter&apos;s Timeline</title>
      <link>https://blog.mdashikjs.com/blog/system-design-twitter-timeline</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/system-design-twitter-timeline</guid>
      <description>The fan-out question is a rite of passage. Every candidate picks fan-out-on-write or fan-out-on-read. The answer that actually scales is neither — it is both, switched on the follower count.</description>
      <pubDate>Sun, 29 Mar 2026 00:00:00 GMT</pubDate>
      <category>System Design</category>
    </item>
    <item>
      <title>5 TypeScript Patterns I Use in Every Production Codebase</title>
      <link>https://blog.mdashikjs.com/blog/typescript-patterns-production</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/typescript-patterns-production</guid>
      <description>These are not clever tricks. They are patterns that prevent entire categories of bugs, make refactoring safe, and keep large codebases navigable. Every one is battle-tested.</description>
      <pubDate>Sat, 28 Mar 2026 00:00:00 GMT</pubDate>
      <category>Backend</category>
    </item>
    <item>
      <title>CAP Theorem in Interview Terms: The Version That Actually Makes Sense</title>
      <link>https://blog.mdashikjs.com/blog/cap-theorem-interview-explained</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/cap-theorem-interview-explained</guid>
      <description>Every system design resource defines CAP. Almost none of them make it useful. Here is the version I explain to candidates, with the one detail most resources get wrong.</description>
      <pubDate>Fri, 27 Mar 2026 00:00:00 GMT</pubDate>
      <category>System Design</category>
    </item>
    <item>
      <title>How I Prepared for FAANG System Design Interviews in 6 Weeks</title>
      <link>https://blog.mdashikjs.com/blog/preparing-faang-system-design-interviews</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/preparing-faang-system-design-interviews</guid>
      <description>I had the fundamentals. What I did not have was a repeatable structure for a 45-minute whiteboard. Here is the plan that got me across the line.</description>
      <pubDate>Thu, 26 Mar 2026 00:00:00 GMT</pubDate>
      <category>Career</category>
    </item>
    <item>
      <title>What &apos;The Clean Coder&apos; Taught Me About Saying No</title>
      <link>https://blog.mdashikjs.com/blog/clean-coder-saying-no-professionally</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/clean-coder-saying-no-professionally</guid>
      <description>Uncle Bob&apos;s best book is not about code. It is about the moments when the right answer to a manager is &apos;no&apos; and the cost of not saying it. Three lessons that stuck with me.</description>
      <pubDate>Wed, 25 Mar 2026 00:00:00 GMT</pubDate>
      <category>Career</category>
    </item>
    <item>
      <title>Clean Code vs Readable Code: Where Uncle Bob Ages Well and Where He Doesn&apos;t</title>
      <link>https://blog.mdashikjs.com/blog/clean-code-vs-readable-code-lessons</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/clean-code-vs-readable-code-lessons</guid>
      <description>&apos;Clean Code&apos; shaped a generation of developers. Some of the rules still hold. Some have aged badly. Here is a honest re-read a decade after I first bought the book.</description>
      <pubDate>Tue, 24 Mar 2026 00:00:00 GMT</pubDate>
      <category>Career</category>
    </item>
    <item>
      <title>5 Programming Books That Actually Changed My Day-to-Day Code</title>
      <link>https://blog.mdashikjs.com/blog/programming-books-changed-my-code</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/programming-books-changed-my-code</guid>
      <description>Every engineer has a reading list they recommend. Most of those books are fine. These five are the ones whose fingerprints I can see in the code I shipped this month.</description>
      <pubDate>Mon, 23 Mar 2026 00:00:00 GMT</pubDate>
      <category>Career</category>
    </item>
    <item>
      <title>How I Implemented Redis Caching in NestJS</title>
      <link>https://blog.mdashikjs.com/blog/redis-caching-nestjs</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/redis-caching-nestjs</guid>
      <description>Database round-trips were the bottleneck in our NestJS API. Here is how a disciplined cache-aside layer dropped P95 latency from 340ms to 28ms without making invalidation painful.</description>
      <pubDate>Wed, 18 Mar 2026 00:00:00 GMT</pubDate>
      <category>Backend</category>
    </item>
    <item>
      <title>Secure File Uploads with AWS S3 Presigned URLs</title>
      <link>https://blog.mdashikjs.com/blog/aws-s3-presigned-urls-uploads</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/aws-s3-presigned-urls-uploads</guid>
      <description>Routing file uploads through your server is a bottleneck. Presigned URLs let clients upload directly to S3 while your server keeps full control over what gets uploaded and where.</description>
      <pubDate>Thu, 12 Mar 2026 00:00:00 GMT</pubDate>
      <category>Cloud</category>
    </item>
    <item>
      <title>Rate Limiting APIs: Sliding Window vs Token Bucket</title>
      <link>https://blog.mdashikjs.com/blog/rate-limiting-api-strategies</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/rate-limiting-api-strategies</guid>
      <description>Every API needs rate limiting. The question is which algorithm fits your traffic pattern. I have implemented both in production and the tradeoffs are not obvious until you see real traffic.</description>
      <pubDate>Thu, 05 Mar 2026 00:00:00 GMT</pubDate>
      <category>System Design</category>
    </item>
    <item>
      <title>Building a Type-Safe API Layer with tRPC and Next.js</title>
      <link>https://blog.mdashikjs.com/blog/trpc-nextjs-type-safe-api</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/trpc-nextjs-type-safe-api</guid>
      <description>I have shipped REST, GraphQL, and now tRPC in production. For an app where one team owns both the frontend and the backend, tRPC is the most productive by a wide margin.</description>
      <pubDate>Sun, 22 Feb 2026 00:00:00 GMT</pubDate>
      <category>Backend</category>
    </item>
    <item>
      <title>Next.js Server Components: Data Fetching Without the Waterfall</title>
      <link>https://blog.mdashikjs.com/blog/nextjs-server-components-data-fetching</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/nextjs-server-components-data-fetching</guid>
      <description>Server Components changed how I think about data fetching in Next.js. The key insight: fetch where you render, not in a top-level loader. But there are traps if you are not careful about parallelism.</description>
      <pubDate>Sun, 15 Feb 2026 00:00:00 GMT</pubDate>
      <category>Frontend</category>
    </item>
    <item>
      <title>PostgreSQL JSONB: When to Use It and When to Normalize</title>
      <link>https://blog.mdashikjs.com/blog/postgresql-jsonb-when-to-use</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/postgresql-jsonb-when-to-use</guid>
      <description>JSONB is powerful but it is not a replacement for proper schema design. After using it in three production systems, I have a clear mental model for when it helps and when it hurts.</description>
      <pubDate>Sun, 08 Feb 2026 00:00:00 GMT</pubDate>
      <category>Backend</category>
    </item>
    <item>
      <title>A Production-Grade CI Pipeline with GitHub Actions</title>
      <link>https://blog.mdashikjs.com/blog/github-actions-ci-pipeline-node</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/github-actions-ci-pipeline-node</guid>
      <description>Our CI pipeline runs lint, type-check, tests, build, and security audit in under 3 minutes. Here is the exact workflow file and the decisions behind each step.</description>
      <pubDate>Wed, 28 Jan 2026 00:00:00 GMT</pubDate>
      <category>DevOps</category>
    </item>
    <item>
      <title>Scaling WebSockets to 50K Connections with Redis Pub/Sub</title>
      <link>https://blog.mdashikjs.com/blog/websocket-scaling-redis-pubsub</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/websocket-scaling-redis-pubsub</guid>
      <description>A single Node.js process handles WebSocket connections just fine. The problem starts when you have multiple servers. Redis Pub/Sub solved our cross-server messaging without a dedicated message broker.</description>
      <pubDate>Tue, 20 Jan 2026 00:00:00 GMT</pubDate>
      <category>System Design</category>
    </item>
    <item>
      <title>Scaling MongoDB to 200K Users: Lessons Learned</title>
      <link>https://blog.mdashikjs.com/blog/scaling-mongodb-200k-users</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/scaling-mongodb-200k-users</guid>
      <description>When I joined, the cluster was a single replica set handling 40K daily users. 18 months later we were at 200K with a 2x-improved P95. Here is what actually moved the needle.</description>
      <pubDate>Sat, 10 Jan 2026 00:00:00 GMT</pubDate>
      <category>Backend</category>
    </item>
    <item>
      <title>Structured Error Handling in NestJS: Beyond Try-Catch</title>
      <link>https://blog.mdashikjs.com/blog/api-error-handling-nestjs</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/api-error-handling-nestjs</guid>
      <description>Most error handling I see in Node.js APIs is ad hoc try-catch blocks that return inconsistent shapes. Here is the pattern I use to make errors predictable, debuggable, and client-friendly.</description>
      <pubDate>Mon, 05 Jan 2026 00:00:00 GMT</pubDate>
      <category>Backend</category>
    </item>
    <item>
      <title>Database Migrations Without Downtime: A Practical Guide</title>
      <link>https://blog.mdashikjs.com/blog/database-migrations-safe-practices</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/database-migrations-safe-practices</guid>
      <description>Every deployment that includes a migration is a risk. The difference between a smooth deploy and a 3am incident is how you structure the migration. Here are the rules I follow.</description>
      <pubDate>Sat, 20 Dec 2025 00:00:00 GMT</pubDate>
      <category>Backend</category>
    </item>
    <item>
      <title>JWT Authentication Done Right: Access Tokens and Refresh Tokens</title>
      <link>https://blog.mdashikjs.com/blog/jwt-authentication-refresh-tokens</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/jwt-authentication-refresh-tokens</guid>
      <description>Most JWT tutorials show you how to sign a token and call it a day. Production auth needs short-lived access tokens, refresh token rotation, and a clear revocation strategy. Here is the full picture.</description>
      <pubDate>Wed, 10 Dec 2025 00:00:00 GMT</pubDate>
      <category>Security</category>
    </item>
    <item>
      <title>React Performance: The Optimization Checklist I Actually Use</title>
      <link>https://blog.mdashikjs.com/blog/react-performance-optimization</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/react-performance-optimization</guid>
      <description>I have seen too many React apps slow down because of premature optimization or, worse, no optimization at all. Here is the checklist I follow when a component feels sluggish.</description>
      <pubDate>Fri, 28 Nov 2025 00:00:00 GMT</pubDate>
      <category>Frontend</category>
    </item>
    <item>
      <title>Zero-Downtime Deploys with PM2 and GitHub Actions</title>
      <link>https://blog.mdashikjs.com/blog/zero-downtime-deploys-pm2-github-actions</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/zero-downtime-deploys-pm2-github-actions</guid>
      <description>Zero downtime sounds like magic. It is mostly discipline: reload instead of restart, health checks before trusting the new version, and enough instances that one going down does not matter.</description>
      <pubDate>Sat, 15 Nov 2025 00:00:00 GMT</pubDate>
      <category>DevOps</category>
    </item>
    <item>
      <title>Event-Driven Architecture in Node.js: Patterns That Scale</title>
      <link>https://blog.mdashikjs.com/blog/event-driven-architecture-nodejs</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/event-driven-architecture-nodejs</guid>
      <description>Direct function calls couple your modules. Events decouple them. But event-driven architecture has its own set of traps — lost events, ordering issues, and debugging nightmares. Here is how I handle them.</description>
      <pubDate>Sat, 08 Nov 2025 00:00:00 GMT</pubDate>
      <category>System Design</category>
    </item>
    <item>
      <title>Nginx as a Reverse Proxy for Node.js: The Production Config</title>
      <link>https://blog.mdashikjs.com/blog/nginx-reverse-proxy-nodejs</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/nginx-reverse-proxy-nodejs</guid>
      <description>Node.js should not serve static files, terminate SSL, or handle rate limiting. That is Nginx&apos;s job. Here is the production config I copy into every new project.</description>
      <pubDate>Sat, 25 Oct 2025 00:00:00 GMT</pubDate>
      <category>DevOps</category>
    </item>
    <item>
      <title>Clean Architecture in NestJS: Separating Business Logic from Framework</title>
      <link>https://blog.mdashikjs.com/blog/clean-architecture-nestjs</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/clean-architecture-nestjs</guid>
      <description>NestJS gives you modules, services, and controllers. But putting all your logic in services couples your business rules to the framework. Here is how I structure NestJS projects so the core logic is portable and testable.</description>
      <pubDate>Wed, 15 Oct 2025 00:00:00 GMT</pubDate>
      <category>Backend</category>
    </item>
    <item>
      <title>Monitoring Node.js in Production: Metrics That Actually Matter</title>
      <link>https://blog.mdashikjs.com/blog/monitoring-nodejs-production</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/monitoring-nodejs-production</guid>
      <description>Most teams monitor CPU and memory and call it a day. Those metrics tell you the server is alive, not that the application is healthy. Here are the metrics I track and why.</description>
      <pubDate>Sun, 05 Oct 2025 00:00:00 GMT</pubDate>
      <category>DevOps</category>
    </item>
    <item>
      <title>API Versioning: URL Path vs Headers vs Content Negotiation</title>
      <link>https://blog.mdashikjs.com/blog/api-versioning-strategies</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/api-versioning-strategies</guid>
      <description>Your API will change. The question is how to evolve it without breaking existing clients. I have used all three common strategies and each has a clear sweet spot.</description>
      <pubDate>Sun, 28 Sep 2025 00:00:00 GMT</pubDate>
      <category>System Design</category>
    </item>
    <item>
      <title>My Testing Strategy for Backend APIs: What to Test and What to Skip</title>
      <link>https://blog.mdashikjs.com/blog/testing-strategy-backend-apis</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/testing-strategy-backend-apis</guid>
      <description>100 percent code coverage is a vanity metric. The goal is confidence that the system works, not that every line has been executed. Here is how I decide what to test and at which level.</description>
      <pubDate>Mon, 15 Sep 2025 00:00:00 GMT</pubDate>
      <category>Backend</category>
    </item>
    <item>
      <title>Caching at Every Layer: Browser, CDN, API, and Database</title>
      <link>https://blog.mdashikjs.com/blog/caching-strategies-full-stack</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/caching-strategies-full-stack</guid>
      <description>Caching is not a single decision. It is a stack of decisions at every layer, each with different tradeoffs. Here is how I think about caching from the browser all the way down to the database.</description>
      <pubDate>Fri, 05 Sep 2025 00:00:00 GMT</pubDate>
      <category>System Design</category>
    </item>
    <item>
      <title>Blue-Green and Canary Deployments: Shipping Without Fear</title>
      <link>https://blog.mdashikjs.com/blog/blue-green-canary-deployments</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/blue-green-canary-deployments</guid>
      <description>Rolling back a broken deploy should take 30 seconds, not 30 minutes. Blue-green and canary deployments give you that confidence by separating the release from the deploy.</description>
      <pubDate>Fri, 01 Aug 2025 00:00:00 GMT</pubDate>
      <category>DevOps</category>
    </item>
    <item>
      <title>Background Jobs in Node.js with BullMQ and Redis</title>
      <link>https://blog.mdashikjs.com/blog/bullmq-background-jobs-nodejs</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/bullmq-background-jobs-nodejs</guid>
      <description>Not everything belongs in the request-response cycle. Email sending, PDF generation, and data exports should happen in the background. BullMQ gives you reliable job queues with retries, priorities, and concurrency control.</description>
      <pubDate>Tue, 15 Jul 2025 00:00:00 GMT</pubDate>
      <category>Backend</category>
    </item>
    <item>
      <title>Secrets Management in Production: HashiCorp Vault and Beyond</title>
      <link>https://blog.mdashikjs.com/blog/secrets-management-vault-production</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/secrets-management-vault-production</guid>
      <description>Hardcoded secrets in .env files committed to Git is how breaches happen. Here is how we moved to centralized secrets management with HashiCorp Vault and never looked back.</description>
      <pubDate>Tue, 01 Jul 2025 00:00:00 GMT</pubDate>
      <category>Security</category>
    </item>
    <item>
      <title>Horizontal vs Vertical Scaling: When to Scale What</title>
      <link>https://blog.mdashikjs.com/blog/horizontal-vertical-scaling-guide</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/horizontal-vertical-scaling-guide</guid>
      <description>Vertical scaling is simpler. Horizontal scaling is more resilient. The right answer depends on your bottleneck, your budget, and how much operational complexity you can absorb.</description>
      <pubDate>Sun, 15 Jun 2025 00:00:00 GMT</pubDate>
      <category>System Design</category>
    </item>
    <item>
      <title>TypeScript Generics: A Practical Guide Beyond the Basics</title>
      <link>https://blog.mdashikjs.com/blog/typescript-generics-practical-guide</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/typescript-generics-practical-guide</guid>
      <description>Generics are TypeScript&apos;s most powerful feature and its most confusing one. Here are the patterns I use daily — not academic type theory, but practical code that makes refactoring safe and APIs self-documenting.</description>
      <pubDate>Sun, 01 Jun 2025 00:00:00 GMT</pubDate>
      <category>Backend</category>
    </item>
    <item>
      <title>Next.js Middleware and Edge Functions in Production</title>
      <link>https://blog.mdashikjs.com/blog/nextjs-middleware-edge-functions</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/nextjs-middleware-edge-functions</guid>
      <description>Middleware runs before every request hits your page. At the edge, that means authentication, redirects, and A/B testing happen in under 5ms — before the page even starts rendering.</description>
      <pubDate>Thu, 15 May 2025 00:00:00 GMT</pubDate>
      <category>Frontend</category>
    </item>
    <item>
      <title>SQL vs NoSQL: How I Choose the Right Database for Each Service</title>
      <link>https://blog.mdashikjs.com/blog/sql-vs-nosql-choosing-right</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/sql-vs-nosql-choosing-right</guid>
      <description>The SQL vs NoSQL debate is a false dichotomy. Most systems benefit from both. The real question is which data model fits which service — and I have a checklist for that.</description>
      <pubDate>Thu, 01 May 2025 00:00:00 GMT</pubDate>
      <category>System Design</category>
    </item>
    <item>
      <title>Distributed Tracing with OpenTelemetry in Node.js</title>
      <link>https://blog.mdashikjs.com/blog/distributed-tracing-opentelemetry</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/distributed-tracing-opentelemetry</guid>
      <description>Logs tell you what happened. Metrics tell you how much. Traces tell you where the time went. OpenTelemetry is the standard that ties all three together across service boundaries.</description>
      <pubDate>Tue, 15 Apr 2025 00:00:00 GMT</pubDate>
      <category>DevOps</category>
    </item>
    <item>
      <title>Docker Compose for Local Development That Mirrors Production</title>
      <link>https://blog.mdashikjs.com/blog/docker-compose-local-development</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/docker-compose-local-development</guid>
      <description>The &apos;works on my machine&apos; problem is a configuration problem. Docker Compose gives every developer the same PostgreSQL, Redis, and Elasticsearch versions as production — with one command.</description>
      <pubDate>Tue, 01 Apr 2025 00:00:00 GMT</pubDate>
      <category>DevOps</category>
    </item>
    <item>
      <title>PostgreSQL Query Optimization: From 8 Seconds to 20ms</title>
      <link>https://blog.mdashikjs.com/blog/postgres-query-optimization</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/postgres-query-optimization</guid>
      <description>The query worked fine with 10K rows. At 2M rows it took 8 seconds. The fix was not a bigger server — it was understanding EXPLAIN ANALYZE output and fixing the query plan.</description>
      <pubDate>Sat, 15 Mar 2025 00:00:00 GMT</pubDate>
      <category>Backend</category>
    </item>
    <item>
      <title>API Gateway Patterns with Kong in Production</title>
      <link>https://blog.mdashikjs.com/blog/api-gateway-kong-microservices</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/api-gateway-kong-microservices</guid>
      <description>Without an API gateway, every microservice reimplements authentication, rate limiting, and logging. Kong centralizes these concerns so your services can focus on business logic.</description>
      <pubDate>Sat, 01 Mar 2025 00:00:00 GMT</pubDate>
      <category>System Design</category>
    </item>
    <item>
      <title>Structured Logging: Why JSON Logs Changed How We Debug</title>
      <link>https://blog.mdashikjs.com/blog/structured-logging-production</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/structured-logging-production</guid>
      <description>Unstructured log lines are grep-friendly until you need to correlate a request across three services. Structured JSON logs with trace IDs turned our debugging from guesswork into queries.</description>
      <pubDate>Sat, 15 Feb 2025 00:00:00 GMT</pubDate>
      <category>DevOps</category>
    </item>
    <item>
      <title>Real-Time Event Processing with Redis Streams</title>
      <link>https://blog.mdashikjs.com/blog/redis-streams-event-processing</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/redis-streams-event-processing</guid>
      <description>Redis Streams sit between pub/sub and a full message broker. They give you persistent, ordered event logs with consumer groups — powerful enough for most event-driven systems without the operational cost of Kafka.</description>
      <pubDate>Sat, 01 Feb 2025 00:00:00 GMT</pubDate>
      <category>Backend</category>
    </item>
    <item>
      <title>Load Balancing Algorithms: Round Robin, Least Connections, and Beyond</title>
      <link>https://blog.mdashikjs.com/blog/load-balancing-algorithms-explained</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/load-balancing-algorithms-explained</guid>
      <description>Choosing a load balancing algorithm is choosing a trade-off. Round robin is simple but blind. Least connections is smarter but stateful. Here is when each one makes sense.</description>
      <pubDate>Sat, 18 Jan 2025 00:00:00 GMT</pubDate>
      <category>System Design</category>
    </item>
    <item>
      <title>Building Full-Text Search with Elasticsearch and Node.js</title>
      <link>https://blog.mdashikjs.com/blog/elasticsearch-full-text-search</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/elasticsearch-full-text-search</guid>
      <description>PostgreSQL&apos;s full-text search is good enough until it is not. When we needed fuzzy matching, faceted results, and sub-50ms queries across 2M documents, Elasticsearch was the right tool.</description>
      <pubDate>Thu, 02 Jan 2025 00:00:00 GMT</pubDate>
      <category>Backend</category>
    </item>
    <item>
      <title>OAuth 2.0 and OpenID Connect: A Practical Implementation Guide</title>
      <link>https://blog.mdashikjs.com/blog/oauth2-openid-connect-guide</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/oauth2-openid-connect-guide</guid>
      <description>OAuth 2.0 is an authorization framework, not an authentication protocol. OpenID Connect adds the authentication layer on top. Getting this distinction wrong is the root of most auth bugs I have debugged.</description>
      <pubDate>Fri, 20 Dec 2024 00:00:00 GMT</pubDate>
      <category>Security</category>
    </item>
    <item>
      <title>The Circuit Breaker Pattern: Stop Cascading Failures</title>
      <link>https://blog.mdashikjs.com/blog/circuit-breaker-pattern-resilience</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/circuit-breaker-pattern-resilience</guid>
      <description>When a downstream service goes down, the worst thing your app can do is keep hammering it. The circuit breaker pattern fails fast, gives the struggling service time to recover, and keeps your system responsive.</description>
      <pubDate>Thu, 05 Dec 2024 00:00:00 GMT</pubDate>
      <category>System Design</category>
    </item>
    <item>
      <title>Managing AWS Infrastructure with Terraform</title>
      <link>https://blog.mdashikjs.com/blog/terraform-aws-infrastructure</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/terraform-aws-infrastructure</guid>
      <description>ClickOps is how infrastructure breaks silently. Terraform lets you version-control your cloud, review changes before they happen, and reproduce any environment from a single command.</description>
      <pubDate>Mon, 25 Nov 2024 00:00:00 GMT</pubDate>
      <category>DevOps</category>
    </item>
    <item>
      <title>Database Connection Pooling: Why Your App Is Leaking Connections</title>
      <link>https://blog.mdashikjs.com/blog/database-connection-pooling</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/database-connection-pooling</guid>
      <description>Every unmanaged database connection is a file descriptor, a TCP socket, and a chunk of memory on both sides. Connection pooling is not an optimization — it is a requirement for any app that serves more than hobby traffic.</description>
      <pubDate>Sun, 10 Nov 2024 00:00:00 GMT</pubDate>
      <category>Backend</category>
    </item>
    <item>
      <title>gRPC for Node.js Microservice Communication</title>
      <link>https://blog.mdashikjs.com/blog/grpc-nodejs-service-communication</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/grpc-nodejs-service-communication</guid>
      <description>REST is fine for public APIs. But for internal service-to-service calls where latency and payload size matter, gRPC with Protocol Buffers is measurably faster and catches contract drift at compile time.</description>
      <pubDate>Fri, 25 Oct 2024 00:00:00 GMT</pubDate>
      <category>Backend</category>
    </item>
    <item>
      <title>Taming AWS Lambda Cold Starts in Production</title>
      <link>https://blog.mdashikjs.com/blog/serverless-lambda-cold-starts</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/serverless-lambda-cold-starts</guid>
      <description>Cold starts are the tax you pay for not managing servers. In our payment processing Lambda, that tax was 3 seconds on the first invocation. Here is how we brought it under 200ms.</description>
      <pubDate>Sat, 05 Oct 2024 00:00:00 GMT</pubDate>
      <category>Cloud</category>
    </item>
    <item>
      <title>Advanced Prisma Patterns: Relations, Transactions, and Raw Queries</title>
      <link>https://blog.mdashikjs.com/blog/prisma-advanced-queries</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/prisma-advanced-queries</guid>
      <description>Prisma is great until it is not. Nested creates, interactive transactions, and knowing when to drop to raw SQL are the three skills that separate a smooth Prisma experience from a frustrating one.</description>
      <pubDate>Fri, 20 Sep 2024 00:00:00 GMT</pubDate>
      <category>Backend</category>
    </item>
    <item>
      <title>Deploying Node.js to Kubernetes: A Practical Guide</title>
      <link>https://blog.mdashikjs.com/blog/kubernetes-deploying-nodejs</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/kubernetes-deploying-nodejs</guid>
      <description>Kubernetes has a steep learning curve, but for a Node.js backend the core concepts boil down to four manifests. Here is the minimal setup that got us to production with rolling updates, health checks, and auto-scaling.</description>
      <pubDate>Sun, 01 Sep 2024 00:00:00 GMT</pubDate>
      <category>DevOps</category>
    </item>
    <item>
      <title>Building Real-Time Features with GraphQL Subscriptions</title>
      <link>https://blog.mdashikjs.com/blog/graphql-subscriptions-real-time</link>
      <guid isPermaLink="true">https://blog.mdashikjs.com/blog/graphql-subscriptions-real-time</guid>
      <description>REST polling wastes bandwidth. WebSockets are low-level. GraphQL subscriptions sit in the sweet spot: real-time push with the same type-safe schema you already use for queries and mutations.</description>
      <pubDate>Thu, 15 Aug 2024 00:00:00 GMT</pubDate>
      <category>Backend</category>
    </item>
  </channel>
</rss>