DEV Community: Irshad's Intersection

HTTP Request Lifecycle Explained — What Really Happens When You Hit Enter

Irshad's Intersection — Tue, 31 Mar 2026 12:46:24 +0000

You type https://google.com into your browser and press Enter.

In about 200 milliseconds, a fully rendered page appears.

But what actually happened in those 200 milliseconds?

Most developers — even experienced ones — have a vague idea. ‘DNS happens, then TCP, then… HTTP stuff.’ But if you’re building backends, designing APIs, debugging slow responses, or preparing for system design interviews, ‘vague’ is not good enough.

In this post, we’re going to trace every single thing that happens — from the moment you press Enter to the moment the response arrives — explained in plain language with real examples and actual HTTP messages.

Let’s go.

The 7 Stages at a Glance
Before we dive deep into each stage, here’s the full picture:

Stage What Happens Who Does It

URL Parsing Browser breaks down the URL into parts Browser
DNS Lookup Domain name is resolved to an IP address OS + DNS Servers
TCP Handshake A reliable connection is established Client + Server
TLS Handshake Connection is encrypted (HTTPS only) Client + Server
HTTP Request Client sends the actual request message Browser / HTTP Client
Server Processing Server receives, routes, processes, and responds Your Backend Code
Connection End Connection is closed or kept alive for future requests Client + Server 💡 As a backend developer, you directly control Stage 6 (Server Processing). But understanding Stages 1-5 is what lets you diagnose slow APIs, set correct headers, design better systems, and answer senior-level interview questions. Stage 1 URL Parsing

Before anything goes over the network, the browser breaks down what you typed into structured parts.

Take this URL: https://api.example.com:443/users/42?format=json#profile

Part Value What it means
Scheme https Use HTTPS protocol (encrypted HTTP)
Host api.example.com The domain name to connect to
Port 443 Port number (443 is default for HTTPS, 80 for HTTP)
Path /users/42 The specific resource being requested
Query ?format=json Additional parameters passed to the server
Fragment #profile Client-side anchor — never sent to the server
🔑 The fragment (#profile) is NEVER sent to the server. It is processed entirely by the browser. Your backend will never see it. This is a classic interview gotcha.
The browser also checks a few things at this stage:

Is this a valid URL format?
Is the scheme supported (http, https, ftp, etc.)?
If no port is specified — assume 80 for HTTP, 443 for HTTPS
Encode any special characters in the path or query using percent-encoding (spaces become %20, etc.)
Stage 2 DNS Lookup — Translating Domain to IP Address

Your computer does not know where ‘api.example.com’ is. It only understands IP addresses — numerical addresses like 142.250.80.46. DNS (Domain Name System) is the phonebook that translates one to the other.

The DNS Resolution Chain
DNS lookup does not happen in one step. It’s a chain of queries, each one more specific than the last:

Step Where it checks What it does
1 Browser DNS cache Did I recently look up this domain? Use cached IP.
2 OS DNS cache Has this machine looked it up? Check /etc/hosts and OS cache.
3 Router / ISP DNS Ask the local DNS resolver (usually your router or ISP).
4 Root DNS servers 13 root servers worldwide. Returns address of TLD nameserver.
5 TLD nameserver (.com, .in) Returns address of the domain’s authoritative nameserver.
6 Authoritative nameserver Returns the actual IP address for the domain.

READ FULL POST: https://dailydevnotes.in/slug-http-request-lifecycle-explained-backend/

LeetCode 11 — Container With Most Water | Full Solution Explained

Irshad's Intersection — Sat, 28 Mar 2026 14:16:45 +0000

Difficulty Pattern Asked At LeetCode Link
Medium Two Pointers (Opposite Ends) Amazon, Google, Microsoft, Bloomberg, Apple leetcode.com/problems/container-with-most-water
📌 This is part of the Two Pointers series on Daily Dev Notes. If you haven’t read the Two Pointers pattern guide yet, start there — it will make this solution much easier to understand.
This problem has a sneaky quality to it.

When you first read it, it looks like a geometry problem. But once you see the right way to think about it, it becomes a clean, elegant Two Pointers problem that solves in a single pass.

The hard part is not the code — the code is just 10 lines. The hard part is building the intuition for why the Two Pointers approach is correct. That’s what this post focuses on.

Let’s go from scratch.

The Problem Statement
You are given an integer array height of length n. There are n vertical lines drawn such that the two endpoints of the i-th line are at (i, 0) and (i, height[i]).

Find two lines that together with the x-axis form a container that holds the most water. Return the maximum amount of water a container can store.

Note: You cannot slant the container.

Example

Example 1:
Input: height = [1, 8, 6, 2, 5, 4, 8, 3, 7]
Output: 49
Why: Lines at index 1 (height=8) and index 8 (height=7)
Width = 8 - 1 = 7
Height = min(8, 7) = 7
Area = 7 × 7 = 49

Example 2:
Input: height = [1, 1]
Output: 1
Why: Only two lines. Width=1, Height=min(1,1)=1, Area=1
Understanding the Area Formula
Before jumping into the solution, let’s make sure the area calculation is completely clear.

If you pick two lines at positions i and j (where i < j), the water they can hold is:

Example

Area = width × height
= (j - i) × min(height[i], height[j])

The height is min() of the two lines because water spills
over the shorter one — you can never fill above the shorter line.
💡 The area is always limited by the SHORTER line. This single observation is the entire key to understanding why the Two Pointers approach works.
Step 1 — Brute Force Approach
As always, let’s start with the obvious solution. Check every possible pair of lines and track the maximum area.

Brute Force

// Brute Force — O(n²) time, O(1) space
int maxArea(vector& height) {
int maxWater = 0;
int n = height.size();

for (int i = 0; i < n; i++) {
    for (int j = i + 1; j < n; j++) {
        int width  = j - i;
        int h      = min(height[i], height[j]);
        int area   = width * h;
        maxWater   = max(maxWater, area);
    }
}
return maxWater;

}
Metric Brute Force Impact
Time Complexity O(n²) Two nested loops — for n=10,000, that’s 100 million operations
Space Complexity O(1) Fine — no extra data structures
LeetCode Result TLE Fails on large test cases — Time Limit Exceeded
⚠️ The brute force is logically correct but too slow. For n = 100,000 lines, it would need 10 billion comparisons. We need O(n).
Step 2 — Building the Intuition
This is the most important section. Read it slowly.

Let’s start with two pointers — one at the leftmost line (index 0) and one at the rightmost line (index n-1). This gives us the maximum possible width.

Now we calculate the area. Then we ask: should we move the left pointer or the right pointer?

🤔 Here is the key question: if we move one pointer inward, the WIDTH always decreases. So for the area to possibly increase, the HEIGHT must increase. Which pointer should we move to give the HEIGHT a chance to increase?
The Proof — Why We Always Move the Shorter Line
Say the left line has height 3 and the right line has height 8. The current area is limited by height 3 (the shorter one).

What if we move the RIGHT pointer (height 8) inward?

Width decreases Always — we moved inward
New right line height Could be anything — but the area is STILL limited by left line (height 3)
Can area increase? NO — width went down, height is still capped at 3. Area can only stay same or decrease.
What if we move the LEFT pointer (height 3) inward?

Width decreases Always — we moved inward
New left line height Could be greater than 3 — this is our only chance for area to increase
Can area increase? YES — if the new left height is greater than 3, the effective height increases and might outweigh the width decrease
🔑 CONCLUSION: Always move the pointer pointing to the SHORTER line. Moving the taller line’s pointer can never increase the area. Moving the shorter line’s pointer is the only move that gives us a chance at a larger area.
This is the entire algorithm. Everything else — the code, the loop — is just implementing this one insight.

Step 3 — Full Dry Run
Let’s trace through Example 1 completely.

Dry Run

height = [1, 8, 6, 2, 5, 4, 8, 3, 7]
index = [0, 1, 2, 3, 4, 5, 6, 7, 8]
maxArea = 0
Step left right h[left] h[right] Width Height Area maxArea Move
1 0 8 1 7 8 1 8 8 left++ (1 < 7)
2 1 8 8 7 7 7 49 49 right– (8 > 7)
3 1 7 8 3 6 3 18 49 right– (8 > 3)
4 1 6 8 8 5 8 40 49 right– (tie → move right)
5 1 5 8 4 4 4 16 49 right– (8 > 4)
6 1 4 8 5 3 5 15 49 right– (8 > 5)
7 1 3 8 2 2 2 4 49 right– (8 > 2)
8 1 2 8 6 1 6 6 49 right– (8 > 6)
9 1 1 – – – – – 49 left >= right → STOP
✅ Maximum area = 49. Found at Step 2: lines at index 1 (height=8) and index 8 (height=7). Width=7, Height=7, Area=49.
Notice something important in Step 4: when both lines have the same height (both are 8), we can move either pointer — it doesn’t matter. Moving either one cannot increase the area since height stays capped at 8 and width decreases.

READ FULL ARTICLE: https://dailydevnotes.in/leetcode-11-container-with-most-water/

LeetCode 167 — Two Sum II (Input Array Is Sorted) | Full Solution Explained

Irshad's Intersection — Fri, 27 Mar 2026 09:40:55 +0000

Difficulty Pattern Companies Leetcode Link
Medium Two Pointers Amazon, Google, Microsoft, Adobe leetcode.com/problems/two-sum-ii-input-array-is-sorted
📌 Before reading this post, I recommend reading the Two Pointers Pattern Guide on this blog. It will make this solution click much faster.
If you’ve solved the original Two Sum (LeetCode #1), you might think this is the same problem. It’s not — and that one small difference (the array is sorted) completely changes the best approach.

This problem is a textbook example of the Two Pointers pattern. Once you understand why the solution works — not just what the solution is — you’ll be able to apply the same logic to dozens of other problems.

Let’s go through everything from scratch.

The Problem
Given a 1-indexed array of integers called numbers that is already sorted in non-decreasing order, find two numbers such that they add up to a specific target number.

Return the indices of the two numbers (1-indexed) as an integer array of length 2.

Constraint What it means for us
Array is sorted (non-decreasing) We can use Two Pointers — smaller values on left, larger on right
Exactly one solution exists We don’t need to handle ‘no answer’ case
1-indexed output Return index+1 for both answers
Cannot use same element twice Both pointers must point to different positions
Must use O(1) extra space No hash map allowed — this forces the Two Pointers approach
Examples
Example 1:
Input: numbers = [2, 7, 11, 15], target = 9
Output: [1, 2]
Why: numbers[0] + numbers[1] = 2 + 7 = 9

Example 2:
Input: numbers = [2, 3, 4], target = 6
Output: [1, 3]
Why: numbers[0] + numbers[2] = 2 + 4 = 6

Example 3:
Input: numbers = [-1, 0], target = -1
Output: [1, 2]
Why: numbers[0] + numbers[1] = -1 + 0 = -1
Step 1 — The Brute Force Approach (and Why It’s Not Good Enough)
Before jumping to the optimal solution, let’s think about brute force. This is how most people approach the problem first — and it’s perfectly fine to start here.

The brute force idea: check every possible pair of numbers. For each element at index i, loop through every element at index j (where j > i) and check if they add up to the target.

Brute force
// Brute Force — O(n²) time
int n = nums.size();
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (nums[i] + nums[j] == target) {
return {i + 1, j + 1}; // 1-indexed
}
}
}
Metric Brute Force Why it’s a problem
Time Complexity O(n²) Two nested loops — too slow for large inputs
Space Complexity O(1) No extra space — this part is fine
LeetCode Verdict TLE Will fail on large test cases (Time Limit Exceeded)
⚠️ The brute force works logically but gets TLE on LeetCode for large inputs. The interviewer will ask: ‘Can you do better?’ — and the answer is yes, using Two Pointers.
Step 2 — Build the Intuition (How to Think About It)
Here’s the key question: what does it mean that the array is sorted?

It means the smallest element is on the left and the largest is on the right. This gives us something very powerful — we can make smart decisions about which direction to move based on whether our current sum is too small or too big.

🤔 Imagine you start with one pointer at the leftmost element (smallest) and one pointer at the rightmost element (largest). Their sum is either equal to the target, less than the target, or greater than the target.
Current Sum vs Target What it tells us What we do
sum == target Found it! Return the indices
sum < target We need a bigger sum Move LEFT pointer right (increase the smaller number)
sum > target We need a smaller sum Move RIGHT pointer left (decrease the larger number)
💡 This works ONLY because the array is sorted. If we need a bigger sum, moving left pointer right always increases the sum. If we need a smaller sum, moving right pointer left always decreases it. This guarantee disappears in an unsorted array.
With this logic, each step either finds the answer or eliminates at least one element from consideration. We never need to backtrack. That’s why this runs in O(n).

Step 3 — Full Dry Run (Trace Every Step)
Let’s trace through Example 1 in detail.

Dry Run

Array: [2, 7, 11, 15]
Index: 0 1 2 3 (0-based internally, 1-based for output)
Target: 9
Step left right nums[left] nums[right] Sum Decision
1 0 3 2 15 17 17 > 9 → move right left
2 0 2 2 11 13 13 > 9 → move right left
3 0 1 2 7 9 9 == 9 → FOUND! return [1, 2]
✅ Answer found in just 3 steps on an array of size 4. Brute force would have taken up to 6 comparisons. On large arrays, the difference is enormous.
Now let’s trace Example 2 as well to make sure we fully understand.

Dry Run

Array: [2, 3, 4]
Index: 0 1 2
Target: 6
Step left right numbers[left] numbers[right] Sum Decision
1 0 2 2 4 6 6 == 6 → FOUND! return [1, 3]
And one more — a case where the pointers have to cross the array before finding the answer.

Dry Run

Array: [1, 2, 3, 4, 6]
Index: 0 1 2 3 4
Target: 6
Step left right numbers[left] numbers[right] Sum Decision
1 0 4 1 6 7 7 > 6 → move right left
2 0 3 1 4 5 5 < 6 → move left right
3 1 3 2 4 6 6 == 6 → FOUND! return [2, 4]

READ FULL ARTICLE: https://dailydevnotes.in/leetcode-167-two-sum-ii-two-pointers/

Two Pointers Pattern in DSA — Complete Guide for Beginners

Irshad's Intersection — Thu, 26 Mar 2026 14:41:25 +0000

This is a pattern guide. After reading this, you will be able to recognise and solve Two Pointers problems confidently — not just memorise one solution.

Let me ask you something.

Have you ever solved a LeetCode problem by running two loops — one inside the other — and it worked fine on small inputs but got a ‘Time Limit Exceeded’ on larger ones?

That’s almost always a sign that the problem has a Two Pointers solution waiting to be discovered.

Two Pointers is one of the most important patterns in DSA. Once you understand it deeply, you’ll start seeing it everywhere — in array problems, string problems, linked list problems, and even some graph problems.

This guide explains everything from scratch. No prior pattern knowledge needed.

What is the Two Pointers Pattern?
The idea is beautifully simple.

Instead of using one index to loop through an array, you use two — and move them strategically based on some condition. This allows you to check pairs, ranges, or partitions in a single pass instead of nested loops.

Here’s the key insight:

💡 A brute force solution that uses two nested loops is O(n²). Two Pointers converts many of those problems to O(n) — a massive improvement.
Think of it like this: imagine you have a sorted array of numbers and you want to find two numbers that add up to a target. The brute force approach checks every pair — that’s n × n combinations. The Two Pointers approach starts one pointer at the left end and one at the right end and works inward — that’s just n steps.

Same result. Dramatically less work.

When Should You Use Two Pointers?
The pattern fits when you spot these signals in a problem:

The input is a sorted array or string (or can be sorted without losing the answer)
You need to find a pair, triplet, or subarray satisfying some condition
You need to compare elements from both ends
You need to remove duplicates or partition elements in-place
The problem asks to minimise or maximise a window between two positions
⚠️ Not every array problem is a Two Pointers problem. If the array is unsorted and sorting changes the answer, think of a different approach.

Read Full Article: https://dailydevnotes.in/two-pointers-pattern-dsa/