My writings & engineering articles
Technical Articles
Deep dives into Web Development, React internals, Next.js, TypeScript, Networking, and Systems Engineering. Published live from Medium.
Creating Routes and Handling Requests with Express
What Express.js Is Express.js is a lightweight framework built on top of Node.js’s built-in http module, giving developers a much simpler, cleaner way to build web servers — defini...
What is Node.js? JavaScript on the Server Explained
A JavaScript runtime is not the same thing as the JavaScript language JavaScript, as a language, is just a set of rules — syntax, logic, how variables and functions work. On its ow...
Design Patterns in Java: Why Do We Need Them?
The software-design problem patterns try to solve Imagine two different teams, at two different companies, both building a system that needs to create objects based on some conditi...
Spring and Spring Boot: From IoC to Production-Ready REST APIs
From Spring to a real Java backend application Java backend development runs on Spring more than almost any other framework — and Spring Boot is the reason most developers actually...
How DNS Resolution Works: Tracing google.com with dig
DNS is the internet’s phonebook — but how does the lookup actually happen? You already know DNS translates a domain name into an IP address, the way a phonebook translates a name i...
How a Browser Works: A Beginner-Friendly Guide to Browser Internals
What happens after I type a URL and press Enter? You type a web address, press Enter, and a fraction of a second later, a fully formed page appears — text in place, images loaded, ...
JavaScript Promises Explained for Beginners
A promise is a value that isn’t ready yet You order food delivery. The app doesn’t hand you the food instantly — it hands you a tracking status : your order is being prepared, it’s...
JavaScript Arrays 101
Storing values individually vs using an array Imagine tracking five favorite movies using separate variables: const movie1 = "Inception"; const movie2 = "Interstella...
Understanding HTML Tags and Elements
HTML is the skeleton of a webpage Every webpage you’ve ever visited has a skeleton holding it together — a structure defining what’s a heading, what’s a paragraph, what’s a button,...
What is Middleware in Express and How It Works
A checkpoint between request and response Every request that hits an Express server doesn’t go straight from “arrived” to “answered.” In between, it can pass through a series of ch...
Blocking vs Non-Blocking Code in Node.js
Waiting vs continuing — one line, two very different outcomes Imagine a single cashier at a small shop. A blocking cashier serves one customer completely — ringing up every item, h...
Inside Git: How It Works and the Role of the .git Folder
Beyond the commands: a mental model of Git Most developers learn Git as a set of commands to memorize: git add, git commit, git push. That gets you productive quickly — but it also...
Why Version Control Exists: The Pendrive Problem
project_final_v2_ACTUALLY_FINAL.zip If you’ve ever seen a folder full of files named final, final_v2, final_final, and — somehow, inevitably — final_final_ACTUALLY_final, you alrea...
Map and Set in JavaScript
Problems with traditional objects and arrays Objects and arrays cover most everyday needs — but they each have quiet limitations that eventually surface in real code. Object keys a...
Function Declaration vs Function Expression: What’s the Difference?
What Functions Are and Why We Need Them A function is a reusable block of code — write the logic once, and run it as many times as needed, with different inputs, instead of repeati...
The Magic of this, call(), apply(), and bind() in JavaScript
this = whoever is calling the function, right now this is one of the most confusing words in JavaScript — not because the concept is complicated, but because its value changes depe...
REST API Design Made Simple with Express.js
APIs are just structured conversation between client and server Every time an app loads your profile, saves a new post, or deletes an item from your cart, it’s having a conversatio...
Understanding Network Devices: Modem, Router, Switch, Firewall, and Load Balancer
How does the internet actually reach your home or office? Every request you send — loading a webpage, calling an API, streaming a video — travels through a small chain of physical ...
Synchronous vs Asynchronous JavaScript
Waiting for data, in everyday life Imagine ordering food at a restaurant. A synchronous waiter takes your order, then stands frozen at your table, doing absolutely nothing else, un...
Understanding Object-Oriented Programming in JavaScript
From blueprint to car A car manufacturer doesn’t design a brand-new car from scratch every single time one rolls off the factory line. There’s one blueprint — the design, the speci...
TCP Working: 3-Way Handshake & Reliable Communication
SYN, SYN-ACK, ACK, step by step — how TCP turns an unreliable network into something you can trust.
Async/Await in JavaScript: Writing Cleaner Asynchronous Code
Same promises underneath, read top to bottom — how async/await turns chains into plain, linear code.
Error Handling in JavaScript: Try, Catch, Finally
The difference between an app that crashes and one that fails gracefully — try, catch, finally, explained.
Spread vs Rest Operators in JavaScript
Same three dots, opposite jobs — spread expands a collection, rest gathers values back into one.
Understanding Objects in JavaScript
Key-value pairs, dot vs bracket notation, and how objects differ from arrays — with a hands-on practice set.
Setting Up Your First Node.js Application Step-by-Step
From node -v to a running server — install, REPL, your first script, and Hello World, one step at a time.
How Node.js Handles Multiple Requests with a Single Thread
One chef, a packed restaurant, no confusion — concurrency, the event loop, and why it scales so well.
Control Flow in JavaScript: If, Else, and Switch Explained
Everyday decisions, in code — if, else-if ladders, switch, break, and when to reach for which one.
The new Keyword in JavaScript: Constructors, Objects, and Prototypes
new Car('Tesla') looks like one step — it's actually four. Here's exactly what happens, in order.
Git for Beginners: Basics and Essential Commands
Repositories, commits, and branches explained simply — plus the essential commands for a real Git workflow.
Callbacks in JavaScript: Why They Exist
Functions as values — the idea everything else builds on.
URL Parameters vs Query Strings in Express.js
The same URL, two very different jobs: req.params for identifying resources vs req.query for filtering & sorting.
Getting Started with cURL: Talking to Servers From Your Terminal
Send your first request, read the response, and avoid the mistakes every beginner makes with GET and POST.
Arrow Functions in JavaScript: A Simpler Way to Write Functions
Same functions you already know, with less typing — syntax, implicit return, and lexical this binding.
Template Literals in JavaScript: A Readable Way to Build Strings
Why scattered quotes and plus signs make strings hard to read, and how backticks and ${} fix it cleanly.
Array Flatten in JavaScript: Concepts, Approaches, and Interview Scenarios
Nested arrays, the recursive logic behind flattening, four ways to build it, and the interview variations to expect.
Array Methods You Must Know: push, pop, map, filter, reduce, forEach
Before-and-after examples for the six array methods you'll use constantly, plus a hands-on practice exercise.
JavaScript Modules: Import and Export Explained
Why every file sharing one global scope breaks down at scale, and how export/import fixes it cleanly.
Async Code in Node.js: Callbacks and Promises
Why a single-threaded server needs async code, how callback hell happens, and how promises flatten it out.
Storing Uploaded Files and Serving Them in Express
Where uploads should live, local vs external storage, and how to serve them safely by URL in Express.
Sessions vs JWT vs Cookies: Understanding Authentication Approaches
Cookies are just the delivery truck — sessions and JWT are two different answers to what's inside.
String Polyfills and Common Interview Methods in JavaScript
Build your own trim, reverse, and includes from scratch — and the classic string problems interviews love.
DNS Record Types Explained: NS, A, AAAA, CNAME, MX, and TXT
A clear guide explaining how DNS translates domain names to IP addresses, and how each DNS record type works with real-world analogies.
TCP vs UDP: When to Use What, and How TCP Relates to HTTP
Demystifying transport layer protocols: TCP reliability vs UDP speed, and how HTTP relies on TCP to transfer web data.
Mastering TypeScript: Interfaces, Generics, Unions Explained
If JavaScript already works, why TypeScript — and how interfaces, unions, and generics actually make code safer.
React Hooks Masterclass: useState, useEffect, and Custom Hooks
Understand how React remembers state across renders, side-effect synchronization with useEffect, and building reusable custom hooks.
How React Works Internally: Virtual DOM, Reconciliation, and Rendering
A deep dive into React internals: Fiber architecture, Virtual DOM diffing, reconciliation, and how state updates trigger UI renders.
Realtime Systems: Polling, WebSockets, SSE, and Pub/Sub
Comparing communication patterns for realtime web applications: short/long polling, WebSockets, Server-Sent Events, and Pub/Sub architecture.
Modern Next.js: Routing, Layouts, Server Components, API Routes & Server Actions
Mastering the Next.js App Router: nested layouts, Server vs Client components, API routes, and full-stack Server Actions.
Next.js Explained: Why It Became the Default React Framework
Exploring SSR, SSG, ISR, and automatic optimization features that make Next.js the leading framework for production React apps.
React Fundamentals: Components, JSX, State, and Re-rendering
The essential building blocks of React: component architecture, JSX syntax under the hood, state management, and component lifecycles.
State Management in React: Prop Drilling, Context API, React.memo, useMemo, and useCallback
Solving state complexity in React apps: avoiding prop drilling with Context API and optimizing performance with memoization hooks.
Kafka Explained Like You’re 5: Events, Partitions, and Consumer Groups
How does a large application process millions of events every day? Distributed event streaming explained simply.
Building Scalable Systems: Caching, Rate Limiting and Observability
What happens when your application suddenly gets 1 million users? Architectural patterns for high load.
Securing Apps: Password Hashing, RBAC, OAuth, and OpenID Connect
How does a website know who you are and what you are allowed to do? Modern authentication & authorization.
Prisma vs Drizzle: A Complete Guide to Databases, ORMs, and Choosing the Right Tool
A practical, no-hype comparison of Prisma and Drizzle — plus everything you need to know about databases, ORMs, and migrations first.
Understanding Variables and Data Types in JavaScript
What is a variable and why we need them
Linux File System Hunting — Complete Guide
A comprehensive guide to understanding the Linux file system hierarchy, navigating directories, managing files and permissions.
Looking for more articles?
Read all 52+ articles directly on my Medium profile with full formatting & reader responses.