HTTP/1 vs HTTP/2 vs HTTP/3 — 23 conceptsHTTP/1 vs HTTP/2 vs HTTP/3 — 23 แนวคิด
← → slides · L language · F fullscreen← → เปลี่ยนหน้า · L สลับภาษา · F เต็มจอ
1 / 22

Article summary · The System Design Newsletter #190–191 · Oct 2026สรุปบทความ · The System Design Newsletter #190–191 · ตุลาคม 2026

HTTP/1 vs HTTP/2
vs HTTP/3

23 concepts in two parts: eleven on HTTP/1.x and the workarounds built around it, twelve on what HTTP/2 changed and why HTTP/3 had to change the transport23 แนวคิดใน 2 ตอน: 11 ข้อว่าด้วย HTTP/1.x กับ workaround รอบ ๆ มัน และอีก 12 ข้อว่า HTTP/2 เปลี่ยนอะไร และทำไม HTTP/3 ต้องเปลี่ยนตัว transport

Neo Kim · newsletter.systemdesign.one

Part 1 (#190) + Part 2 (#191)Part 1 (#190) + Part 2 (#191)

Part 1 · HTTP/1.x · #190, Oct 15, 2026Part 1 · HTTP/1.x · #190, 15 ตุลาคม 2026

Eleven concepts, one recurring problem: order11 แนวคิด กับปัญหาเดิมที่วนกลับมา: ลำดับ

1

Request-response cycle

2

TCP three-way handshake

3

Persistent connections

4

Pipelining

5

HTTP head-of-line blocking

6

Chunked transfer encoding

7

Caching & conditional requests

8

Parallel connections & domain sharding

9

TCP slow start

10

Binary framing layer

11

Streams, messages & frames

1–9 are HTTP/1.x and the workarounds built around it · 10–11 are the foundations of HTTP/2ข้อ 1–9 คือ HTTP/1.x กับ workaround ที่สร้างรอบมัน · ข้อ 10–11 คือฐานของ HTTP/2

01 · Request-response cycle01 · Request-response cycle

Every HTTP exchange is one request and one responseทุก HTTP exchange คือ 1 request กับ 1 response

Client Server request: method · path · headers response: status code · headers · body 1 exchange = 1 request + 1 response · HTTP/1.0 opened a new TCP connection for each one

What it isคืออะไร

The client sends a method, a path and headers; the server replies with a status code, headers and usually a body. In HTTP/1.x the format is plain text you could type by hand. Early versions opened a fresh connection for every exchange and threw it away, a decision that shaped 20 years of workarounds.client ส่ง method, path และ headers ส่วน server ตอบ status code, headers และมักมี body ใน HTTP/1.x ข้อความเป็น text ล้วน พิมพ์มือได้ เวอร์ชันแรก ๆ เปิด connection ใหม่ทุก exchange แล้วทิ้ง ซึ่งเป็นต้นตอของ workaround ตลอด 20 ปีต่อมา

Analogy

Ordering by postcard: one item per card, one parcel back. A second item needs a second postcard.สั่งของทางโปสการ์ด ใบละชิ้น ได้พัสดุกลับมาหนึ่งกล่อง อยากได้ชิ้นที่สองก็เขียนใบใหม่

Why it mattersทำไมสำคัญ

Debugging an odd status code starts with the raw exchange, not your app logs. Send requests by hand with curl and read real traffic in the DevTools Network tab.debug status code แปลก ๆ ให้เริ่มจาก raw exchange ไม่ใช่ log ของแอป ยิง request เองด้วย curl แล้วดู traffic จริงใน DevTools Network tab

02 · TCP three-way handshake02 · TCP three-way handshake

Three messages before a single byte of data3 ข้อความ ก่อนจะส่งข้อมูลได้สักไบต์

Client Server SYN SYN-ACK ACK TCP · 1 RTT ClientHello ServerHello + Finished TLS 1.3 · 1 RTT GET / (first request) 200 OK data finally flows

What it isคืออะไร

SYN, SYN-ACK, ACK: one full round trip before the request even leaves your machine. On a 100 ms link that is 100 ms gone. TLS adds more on top: two extra round trips on TLS 1.2, one on TLS 1.3.SYN, SYN-ACK, ACK กิน 1 round trip เต็มก่อน request จะออกจากเครื่องด้วยซ้ำ link 100 ms ก็เสียไป 100 ms แล้ว TLS เพิ่มอีก: TLS 1.2 อีก 2 RTT ส่วน TLS 1.3 เหลือ 1 RTT

Analogy

A phone call: you dial, they say hello, you say hello back, and only on the fourth breath does anyone say something useful.โทรศัพท์: กดโทร เขาฮัลโหล เราฮัลโหลกลับ กว่าจะพูดเรื่องจริงก็ลมหายใจที่สี่

Why it mattersทำไมสำคัญ

Connection setup shows up in your p99 long before your handler code does. Measure it with curl -w and watch it across a full page load in WebPageTest.ค่า connection setup โผล่ใน p99 ก่อน handler ของคุณจะได้ทำงาน วัดด้วย curl -w และดูทั้งหน้าใน WebPageTest

03 · Persistent connections03 · Persistent connections

One handshake, dozens of requestshandshake ครั้งเดียว ใช้ได้หลายสิบ request

TCP handshake request response HTTP/1.0 new connection every time TCP req res TCP req res TCP req res HTTP/1.1 keep-alive TCP req res req res req res 2 handshakes saved time

What it isคืออะไร

HTTP/1.1 keeps the connection open after a response, until either side sends a close header or a timeout fires, so one handshake now covers dozens of requests. A page with 40 assets used to pay 40 handshakes; on one persistent connection it pays one.HTTP/1.1 ค้าง connection ไว้หลังตอบ จนกว่าฝั่งใดจะส่ง header สั่งปิดหรือ timeout ทำงาน handshake ครั้งเดียวเลยครอบคลุมหลายสิบ request หน้าที่มี 40 asset เคยจ่าย 40 handshake เหลือแค่ครั้งเดียว

Analogy

Keeping the line open between questions instead of hanging up and redialing every time you think of something new.ถือสายไว้ถามต่อ แทนที่จะวางแล้วโทรใหม่ทุกครั้งที่นึกคำถามออก

Why it mattersทำไมสำคัญ

Connection churn on a busy proxy exhausts ephemeral ports before bandwidth. Tune keepalive_timeout in nginx and server.keepAliveTimeout in Node, then check both against your load balancer.proxy ที่เปิด-ปิด connection ถี่ ๆ จะหมด ephemeral port ก่อนหมด bandwidth จูน keepalive_timeout ใน nginx และ server.keepAliveTimeout ใน Node แล้วเช็กให้ตรงกับ load balancer

04 · Pipelining04 · Pipelining

Send several requests at once, then wait in orderส่งหลาย request รวดเดียว แล้วรอคำตอบตามลำดับ

sent back to back responses must return in the same order req 1 req 2 req 3 req 4 req req req req res 1 res 2 res 3 res 4 time

What it isคืออะไร

The client fires several requests back to back on one connection without waiting. On paper it removes a round trip per request, but responses must return in the exact order sent, and buggy proxies mangled the traffic. Major browsers disabled it, and so did curl.client ยิงหลาย request ต่อกันบน connection เดียวโดยไม่รอ บนกระดาษประหยัดได้ 1 RTT ต่อ request แต่ response ต้องกลับตามลำดับที่ส่งเป๊ะ ๆ แถม proxy บางตัวจัดการไม่ถูก browser หลักเลยปิดทิ้ง curl ก็เช่นกัน

Analogy

Ordering all three courses at once. The kitchen still serves them in the order you named them, so a slow starter holds up your main.สั่งอาหาร 3 คอร์สรวดเดียว แต่ครัวยังเสิร์ฟตามลำดับที่สั่ง จานแรกช้า จานหลักก็ช้าตาม

Why it mattersทำไมสำคัญ

You will find pipelining switched off everywhere, and now you know why. Confirm with curl and watch real request ordering in Wireshark. Multiplexing solves the same problem without the ordering rule.ที่เห็น pipelining ถูกปิดทุกที่ ตอนนี้รู้แล้วว่าทำไม เช็กด้วย curl และดูลำดับจริงใน Wireshark ส่วน multiplexing แก้ปัญหาเดียวกันโดยไม่ต้องมีกฎลำดับ

05 · HTTP head-of-line blocking05 · HTTP head-of-line blocking

One slow response stalls everything behind itresponse เดียวช้า ที่เหลือค้างทั้งแถว

sent back to back res 2–4 wait for res 1 req 1 req 2 req 3 req 4 req req req req response 1 · slow database query network idle · queue stalled res 2 res 3 res 4 time

What it isคืออะไร

A single HTTP/1.1 connection handles one exchange at a time. A slow database query on request one keeps four others waiting while the network sits idle. Persistent connections removed the handshake cost and left this queue completely intact. It is the ceiling HTTP/1.1 could never lift.HTTP/1.1 connection หนึ่งทำทีละ exchange request แรกติด DB query ช้า อีก 4 ตัวก็ต้องรอทั้งที่ network ว่าง persistent connection ตัดค่า handshake ได้ แต่คิวนี้ยังอยู่ครบ นี่คือเพดานที่ HTTP/1.1 ทะลุไม่ได้

Analogy

A single supermarket checkout: the shopper at the front needs a price check and the four people behind them stand still.ช่องคิดเงินช่องเดียว คนหน้าสุดขอเช็กราคา อีก 4 คนข้างหลังยืนนิ่ง

Why it mattersทำไมสำคัญ

Stair-stepped requests with visible gaps in a waterfall chart point straight at this. Every HTTP/1.1 workaround, from parallel connections to asset bundling, exists to hide this one property.waterfall ที่เป็นขั้นบันไดมีช่องว่าง ชี้มาที่เรื่องนี้ตรง ๆ workaround ของ HTTP/1.1 ทุกอย่าง ตั้งแต่ parallel connection ถึง asset bundling มีไว้ซ่อนคุณสมบัติข้อนี้ข้อเดียว

06 · Chunked transfer encoding06 · Chunked transfer encoding

Send the response in pieces before you know its sizeส่ง response เป็นชิ้น ๆ โดยไม่ต้องรู้ขนาดรวมก่อน

Server 0 · end 3 · data 1a · data 4e · data Browser size in hex before every chunk · a zero-length chunk ends the stream no total size needed up front render starts at the first chunk

What it isคืออะไร

The server marks the response as chunked and writes each piece with its size in hexadecimal; a zero-length chunk marks the end, so the browser can start rendering early. This powers streamed HTML, server-sent events and token-by-token model output. HTTP/2 and HTTP/3 use DATA frames instead.server ติดป้ายว่า chunked แล้วส่งทีละชิ้นพร้อมขนาดเป็นฐาน 16 ปิดท้ายด้วย chunk ขนาด 0 browser จึงเริ่ม render ได้ก่อนครบ นี่คือฐานของ streaming HTML, server-sent events และ token ทีละตัวจากโมเดล ส่วน HTTP/2 และ HTTP/3 ใช้ DATA frame แทน

Analogy

A publisher shipping a book one chapter at a time: you read chapter one while the author is still writing chapter four.สำนักพิมพ์ส่งหนังสือทีละบท คุณอ่านบทหนึ่งตอนที่ผู้เขียนยังเขียนบทสี่อยู่

Why it mattersทำไมสำคัญ

Accidental buffering kills streaming more often than application bugs do. Check proxy_buffering in nginx and res.flushHeaders in Express before blaming your own code.streaming มักพังเพราะโดน buffer โดยไม่ตั้งใจ มากกว่าบั๊กในแอป เช็ก proxy_buffering ใน nginx และ res.flushHeaders ใน Express ก่อนโทษโค้ดตัวเอง

07 · Caching and conditional requests07 · Caching and conditional requests

The cheapest request is the one that never leaves the browserrequest ที่ถูกที่สุด คือ request ที่ไม่เคยออกจาก browser

1 · cache hit (max-age not expired) Browser Local cache 0 bytes · 0 ms 2 · conditional request Browser GET + If-None-Match: <etag> 304 Not Modified · no body Server reuse stored copy

What it isคืออะไร

Cache-Control sets the rules: max-age for freshness, no-cache to force a check, immutable to promise the URL never changes. A conditional request sends the stored ETag in If-None-Match and gets 304 Not Modified with no body. A cache hit costs zero bytes on the wire and zero server time.Cache-Control กำหนดกฎ: max-age บอกอายุความสด, no-cache บังคับเช็กทุกครั้ง, immutable สัญญาว่าไฟล์ใต้ URL นี้ไม่เปลี่ยน conditional request ส่ง ETag ที่เก็บไว้ใน If-None-Match แล้วได้ 304 Not Modified กลับมาแบบไม่มี body cache hit = 0 byte บนสาย และ 0 เวลาของ server

Analogy

Asking a librarian whether the report changed since your last visit. If nothing changed, you read the copy already on your desk.ถามบรรณารักษ์ว่ารายงานเปลี่ยนไหมตั้งแต่มาครั้งก่อน ถ้าไม่ ก็อ่านสำเนาที่อยู่บนโต๊ะอยู่แล้ว

Why it mattersทำไมสำคัญ

Static assets and API responses need opposite policies; mixing them costs freshness or bandwidth. Set rules at the edge (Cloudflare, Varnish) and read the real hit ratio there. Versioned filenames make conditional requests unnecessary.static asset กับ API ต้องการนโยบายตรงข้ามกัน สลับกันเมื่อไหร่เสียความสดหรือ bandwidth ตั้งกฎที่ edge (Cloudflare, Varnish) แล้วดู hit ratio ของจริง ถ้าทำ versioned filename แล้ว conditional request ก็แทบไม่จำเป็น

08 · Parallel connections and domain sharding08 · Parallel connections and domain sharding

Six lanes per hostname, so sites rented more hostnames6 เลนต่อ hostname เว็บเลยไปเพิ่ม hostname

Browser example.com 6 connections static.example.com 6 more connections 12 lanes in total, every one of them starting from TCP slow start again

What it isคืออะไร

Browsers open about six TCP connections to one origin at once, so head-of-line blocking hurts less. Sites wanting more invented extra hostnames: images from one subdomain, scripts from another, six more each. Multiplexing made it obsolete, yet it survives in production.browser เปิด TCP connection ไป origin เดียวราว 6 เส้นพร้อมกัน head-of-line blocking เลยเจ็บน้อยลง เว็บที่อยากได้มากกว่านั้นก็ประดิษฐ์ hostname เพิ่ม: รูปจาก subdomain หนึ่ง script จากอีกอัน ได้อีก 6 ต่อชื่อ multiplexing ทำให้ล้าสมัยไปแล้ว แต่ยังค้างอยู่ใน production

Analogy

Opening more checkout lanes. When six fill up, you rent the shop next door and open six more.เปิดช่องคิดเงินเพิ่ม พอ 6 ช่องเต็มก็เช่าร้านข้าง ๆ เปิดอีก 6

Why it mattersทำไมสำคัญ

Removing dead shards is one of the easier wins on an older codebase. Measure before and after in WebPageTest and let Lighthouse flag the redundant origins.ถอด shard ที่ตายแล้วออกเป็น win ง่าย ๆ ของโค้ดเก่า วัด before/after ใน WebPageTest และให้ Lighthouse ชี้ origin ที่ซ้ำซ้อน

09 · TCP slow start09 · TCP slow start

New connections start slow and double every round tripconnection ใหม่เริ่มช้า แล้วเพิ่มสองเท่าทุก round trip

window (packets) 10 20 40 80 40 42 44 packet loss → window halves RTT 1RTT 2RTT 3RTT 4RTT 5RTT 6RTT 7 ~14 KB28 KB56 KB112 KB56 KB59 KB62 KB

What it isคืออะไร

TCP cannot know the bandwidth between you and your user. Guessing high floods the path and drops packets, so it guesses low and probes upward: the window starts around 10 packets (about 14 KB) and doubles on every successful round trip. Packet loss halves it and switches to a slower climb.TCP ไม่รู้ว่าระหว่างคุณกับผู้ใช้มี bandwidth เท่าไหร่ เดาสูงไปจะท่วมเส้นทางจน packet หล่น เลยเดาต่ำแล้วค่อย ๆ probe ขึ้น: window เริ่มราว 10 packet (ประมาณ 14 KB) และเพิ่มสองเท่าทุก round trip ที่สำเร็จ เจอ packet loss ก็หั่นครึ่งแล้วไต่ช้าลง

Analogy

Merging onto a motorway: you accelerate in stages instead of flooring it blind into traffic you cannot see yet.ขับรถเข้าทางด่วน ค่อย ๆ เร่งเป็นช่วง ไม่ใช่เหยียบมิดทั้งที่ยังมองไม่เห็นรถข้างหน้า

Why it mattersทำไมสำคัญ

The first 14 KB of your HTML carry more weight than the next 500. Put critical CSS and the hero image reference inside that window and let Lighthouse confirm the render path. A reused connection keeps the window it already earned.14 KB แรกของ HTML มีน้ำหนักกว่า 500 KB ถัดไป ใส่ critical CSS และ hero image reference ไว้ใน window นั้น แล้วให้ Lighthouse ยืนยัน render path ส่วน connection ที่ใช้ซ้ำก็เก็บ window ที่ไต่มาได้แล้วไว้

10 · Binary framing layer10 · Binary framing layer

Same semantics, different bytes on the wireความหมายเดิม แต่ byte บนสายไม่เหมือนเดิม

HTTP/1.1 · text lines GET /index.html HTTP/1.1 · Host: example.com · Accept: text/html HTTP/2 · binary frames fixed 9-byte header frame payload length (24 bit) type flags stream id payload: HEADERS / DATA … GET is still GET and 404 is still 404 — only the bytes on the wire change, and frames parse faster and pack tighter than text

What it isคืออะไร

HTTP/2 encodes messages as binary frames instead of text lines. Each frame carries a length, a type, flags and a stream identifier in a fixed nine-byte header. Methods, headers and status codes stay exactly as they were: you still send GET, you still read 404.HTTP/2 encode ข้อความเป็น binary frame แทนบรรทัด text แต่ละ frame มี length, type, flags และ stream identifier ใน header คงที่ 9 byte ส่วน method, headers และ status code เหมือนเดิมเป๊ะ: ยังส่ง GET ยังอ่าน 404

Analogy

Shipping containers replacing loose cargo. The goods are identical; the uniform box is what lets a crane stack, sort and interleave them at speed.ตู้คอนเทนเนอร์แทนสินค้ากองรวม ของเหมือนเดิม แต่กล่องมาตรฐานทำให้เครนยก เรียง และสลับได้เร็ว

Why it mattersทำไมสำคัญ

Reading HTTP/2 traffic needs different tools than HTTP/1.1. Dump frames with nghttp and decode full sessions in Wireshark with a TLS key log.อ่าน traffic HTTP/2 ต้องใช้เครื่องมือคนละชุดกับ HTTP/1.1 dump frame ด้วย nghttp และ decode ทั้ง session ใน Wireshark ด้วย TLS key log

11 · Streams, messages and frames11 · Streams, messages and frames

Many streams on one connection, told apart by a labelหลาย stream บน connection เดียว แยกกันด้วยป้าย

Stream 1GET /index.html Stream 3GET /app.js Stream 5GET /logo.png 1 3 5 1 3 1 5 3 1 5 3 1 3 5 1 one TCP connection · frames from different streams interleave · odd ids = client-initiated, even = server-initiated, always increasing

What it isคืออะไร

A connection carries many streams; each stream is one request-response pair; each message splits into frames tagged with the stream id, so frames from different requests share the wire and reassemble correctly. A few bytes of label per frame is what makes concurrency on one connection practical.connection หนึ่งมีหลาย stream แต่ละ stream คือ 1 คู่ request-response แต่ละ message หั่นเป็น frame ที่ติดป้าย stream id frame จากคนละ request เลยแชร์สายเดียวกันแล้วประกอบคืนถูกที่ ป้ายไม่กี่ byte ต่อ frame นี่แหละที่ทำให้ concurrency บน connection เดียวเป็นจริง

Analogy

One highway with many lanes. Every car carries a destination label, so they travel together and still arrive at different lanes.ทางด่วนหลายเลน รถทุกคันมีป้ายปลายทาง เลยวิ่งปนกันได้แล้วไปถึงคนละเลน

Why it mattersทำไมสำคัญ

Default stream limits rarely match the concurrency your service sees. Set http2_max_concurrent_streams in nginx and the matching limit in Envoy against your real p99.stream limit ค่า default มักไม่ตรงกับ concurrency ของจริง ตั้ง http2_max_concurrent_streams ใน nginx และค่าเทียบเท่าใน Envoy ตาม p99 จริงของคุณ

Part 2 · HTTP/2 vs HTTP/3 · #191, Oct 17, 2026Part 2 · HTTP/2 vs HTTP/3 · #191, 17 ตุลาคม 2026

HTTP/2 fixed the HTTP queue, not the TCP oneHTTP/2 แก้คิวของ HTTP แต่ไม่ใช่คิวของ TCP

12

Multiplexing

13

HPACK header compression

14

Flow control

15

Stream prioritization

16

Server push & early hints

17

TCP head-of-line blocking

Multiplexing, header compression and better connection reuse arrived with HTTP/2, yet one lost TCP packet could still delay every stream. HTTP/3 exists to remove that. Concepts 18–23 sit in the paid part of the newsletter, so this deck covers them by title only.multiplexing, header compression และการใช้ connection ซ้ำที่ดีขึ้นมาพร้อม HTTP/2 แต่ TCP packet หายตัวเดียวก็ยังทำให้ทุก stream ช้าได้ HTTP/3 เกิดมาเพื่อถอดจุดนี้ ส่วนข้อ 18–23 อยู่ในส่วนเสียเงินของ newsletter เด็คนี้จึงเก็บไว้แค่หัวข้อ

12 · Multiplexing12 · Multiplexing

Many requests in flight on one connection, answered in any orderหลาย request วิ่งพร้อมกันบน connection เดียว ตอบลำดับไหนก็ได้

sent together server replies in whatever order the data is ready req 1 req 2 req 3 req 4 req req req req waiting on a slow database query … res 1 res 1 res 1 res 2 res 2 res 2 res 3 res 3 res 4 res 4 res 4 time

What it isคืออะไร

Frames of many requests and responses interleave over one connection, so the queue disappears: request one waits on a slow database while the others return and render, and the server replies in whatever order the data is ready. Desktop pages open fewer connections on HTTP/2 than on HTTP/1.1, roughly half on lighter pages.frame ของหลาย request และ response สลับกันวิ่งบน connection เดียว คิวเลยหายไป: request แรกรอ DB ช้าอยู่ ตัวอื่นก็กลับมา render ได้ server ตอบตามลำดับที่ข้อมูลพร้อม หน้าเว็บบน desktop เปิด connection น้อยลงบน HTTP/2 และบนหน้าเบา ๆ เหลือราวครึ่งเดียว

Analogy

One conversation channel where every sentence carries the speaker’s name. Three people talk at once and nobody loses the thread.ช่องสนทนาเดียวที่ทุกประโยคติดชื่อคนพูด สามคนคุยพร้อมกันก็ไม่มีใครหลุดเรื่อง

Why it mattersทำไมสำคัญ

Multiplexing changes how you bundle: many small files beat one big one for cache reuse. Check the protocol column in DevTools and measure the bundling change in WebPageTest. TCP head-of-line blocking is the limit it could never remove.multiplexing เปลี่ยนวิธี bundle: ไฟล์เล็กหลายไฟล์ชนะไฟล์ใหญ่ไฟล์เดียวเรื่อง cache reuse เช็กคอลัมน์ protocol ใน DevTools แล้ววัดผลการเปลี่ยน bundle ใน WebPageTest ส่วน TCP head-of-line blocking คือขีดจำกัดที่มันถอดไม่ได้

13 · HPACK header compression13 · HPACK header compression

Headers repeat, so send a number insteadheader ซ้ำกันเกือบหมด ก็ส่งเป็นเลขแทน

Request 1 · full headers :method: GET :path: /api/items user-agent: Mozilla/5.0 … cookie: session=a8f3c… ≈ 400 bytes Shared table (both ends) 2 → :method: GET 62 → user-agent: … 63 → cookie: … static entries + dynamic entries Request 2 · indexes 2 · 62 · 63 :path: /api/items/7 (literal) ≈ a few bytes the saving compounds across every request on the connection

What it isคืออะไร

HTTP/2’s header compression: a static table of common header names, a dynamic table shared by both ends, and Huffman coding. User-agent, accept and cookie headers go out identically on every request and on an API-heavy page outweigh the payload. A method line becomes one byte, and later requests reference earlier headers by index.header compression ของ HTTP/2: static table ของชื่อ header ที่ใช้บ่อย, dynamic table ที่สองฝั่งแชร์กัน และ Huffman coding ส่วน user-agent, accept, cookie ส่งซ้ำเหมือนเดิมทุก request และบนหน้าที่ยิง API เยอะ มันหนักกว่า payload เสียอีก บรรทัด method กลายเป็น 1 byte และ request ถัดไปอ้างถึง header เดิมด้วยเลข index

Analogy

Shorthand between two colleagues who talk daily: once you both agree a short name means one specific document, you stop saying the full title.ภาษาย่อระหว่างเพื่อนร่วมงานที่คุยกันทุกวัน พอตกลงกันว่าชื่อสั้น ๆ หมายถึงเอกสารไหน ก็เลิกพูดชื่อเต็ม

Why it mattersทำไมสำคัญ

Header weight decides real latency on pages carrying large authentication tokens. Inspect encoded header sizes in Wireshark and compare against the DevTools network panel. QPACK rebuilds this idea for out-of-order delivery.น้ำหนักของ header ชี้ขาด latency จริงบนหน้าที่แบก authentication token ใหญ่ ๆ ดูขนาด header หลัง encode ใน Wireshark แล้วเทียบกับ DevTools network panel ส่วน QPACK เอาไอเดียนี้ไปสร้างใหม่ให้รองรับการส่งแบบไม่เรียงลำดับ

14 · Flow control14 · Flow control

The receiver decides how much the sender may have in flightฝั่งรับเป็นคนกำหนดว่าฝั่งส่งค้างข้อมูลได้แค่ไหน

Sender Receiver window: 65,535 bytes by default DATA DATA DATA DATA waits for credit WINDOW_UPDATE · more room as the receiver consumes data limits apply per stream and across the whole connection

What it isคืออะไร

Flow control caps the data a sender may have outstanding, per stream and across the whole connection. The receiver sets a window (65,535 bytes by default) and grants more room with WINDOW_UPDATE frames as it consumes data. It protects slow consumers, like a browser decoding a large image, and stops one greedy stream from monopolizing the connection.flow control จำกัดปริมาณข้อมูลที่ฝั่งส่งค้างได้ ทั้งต่อ stream และทั้ง connection ฝั่งรับตั้ง window (ค่าเริ่มต้น 65,535 byte) แล้วให้พื้นที่เพิ่มผ่าน WINDOW_UPDATE frame เมื่อย่อยข้อมูลไปแล้ว มันปกป้องผู้รับที่ช้า เช่น browser ที่กำลัง decode รูปใหญ่ และกัน stream ตะกละตัวเดียวยึด connection ไว้ทั้งหมด

Analogy

A coworker saying “send me five files at a time and I’ll ask for more.” They control the pace, so nothing piles up on their desk.เพื่อนร่วมงานบอกว่า “ส่งมาทีละ 5 ไฟล์ แล้วเดี๋ยวขอเพิ่มเอง” เขาคุมจังหวะเอง งานเลยไม่กองบนโต๊ะ

Why it mattersทำไมสำคัญ

Large uploads, gRPC streams and video segments hit this ceiling before they hit bandwidth. Watch window updates with nghttp and confirm socket-level throughput with ss. QUIC applies the same idea per stream.upload ใหญ่ ๆ, gRPC stream และ video segment ชนเพดานนี้ก่อนชน bandwidth ดู window update ด้วย nghttp และยืนยัน throughput ระดับ socket ด้วย ss ส่วน QUIC ใช้ไอเดียเดียวกันแบบแยกต่อ stream

15 · Stream prioritization15 · Stream prioritization

Tell the server which responses matter mostบอก server ว่า response ไหนสำคัญที่สุด

send order urgency 0 (highest) → 7 (lowest) incremental: can be delivered progressively style.css urgency 0 incremental: no hero.jpg urgency 1 incremental: yes fetchpriority="high" app.js urgency 2 incremental: no footer.png urgency 6 incremental: yes same total bytes, usable page sooner

What it isคืออะไร

A browser needs CSS before a large image to become usable, even if total bytes stay the same. HTTP/2’s dependency-and-weight tree was too complex to implement consistently, so a simpler scheme replaced it: urgency 0–7 and an incremental flag for responses that can be delivered progressively. Browsers also expose the Fetch Priority API (fetchpriority="high").browser ต้องได้ CSS ก่อนรูปใหญ่ถึงจะใช้งานหน้าได้ แม้ byte รวมเท่าเดิม ระบบ dependency กับ weight ของ HTTP/2 ซับซ้อนจน browser และ server ทำไม่ตรงกัน เลยมีแบบง่ายกว่ามาแทน: urgency 0–7 กับ incremental flag สำหรับ response ที่ส่งทยอยได้ browser ยังมี Fetch Priority API (fetchpriority="high") ให้ใช้

Analogy

A triage nurse: everyone in the waiting room gets seen, and the order reflects who needs help soonest.พยาบาลคัดกรอง ทุกคนในห้องรอได้ตรวจหมด แต่ลำดับขึ้นกับว่าใครต้องการความช่วยเหลือก่อน

Why it mattersทำไมสำคัญ

One attribute on your largest visible image moves a headline performance metric. Set fetchpriority in your markup and verify the value in the Chrome DevTools priority column. Early hints reach the same goal from the server side.attribute เดียวบนรูปใหญ่สุดที่มองเห็น ขยับ metric หลักด้าน performance ได้ ใส่ fetchpriority ใน markup แล้วเช็กค่าในคอลัมน์ priority ของ Chrome DevTools ส่วน early hints ไปถึงเป้าเดียวกันจากฝั่ง server

16 · Server push and early hints16 · Server push and early hints

Push sent files you never asked for; early hints only say what’s comingpush ส่งไฟล์ที่ไม่ได้ขอ ส่วน early hints แค่บอกว่าอะไรกำลังจะมา

Server Push · retired Browser Server GET / PUSH_PROMISE + style.css — maybe already in the cache 103 Early Hints Browser Server GET / 103 · Link: </style.css>; rel=preload → browser preconnects and preloads meanwhile 200 OK + HTML, once it is ready

What it isคืออะไร

Server Push sent resources before the browser asked, but it pushed files already in the cache and gains were inconsistent, so Chrome disabled it and Firefox removed it. Early Hints is the simpler replacement: a 103 response with Link headers while the final response is prepared, so the browser can preconnect and preload CSS before the HTML arrives. Adoption is still 2.9% of desktop pages, about 90% of it Shopify.Server Push ส่ง resource ก่อน browser จะขอ แต่มันดันส่งไฟล์ที่อยู่ใน cache แล้ว และผลลัพธ์ไม่สม่ำเสมอ Chrome เลยปิด ส่วน Firefox ถอดออก Early Hints เป็นตัวแทนที่ง่ายกว่า: ตอบ 103 พร้อม Link header ระหว่างเตรียม response จริง browser จึง preconnect และ preload CSS ได้ก่อน HTML มาถึง การใช้งานยังแค่ 2.9% ของหน้า desktop และราว 90% ในนั้นคือ Shopify

Analogy

Push is a waiter setting down a dish you never ordered and may already have. Early hints is a waiter handing you the menu while the kitchen warms up.push คือบริกรวางจานที่ไม่ได้สั่งและอาจมีอยู่แล้ว ส่วน early hints คือบริกรยื่นเมนูให้ระหว่างครัวกำลังอุ่นเตา

Why it mattersทำไมสำคัญ

Dead push configuration survives in production long after browsers stopped honoring it. Enable early hints at Cloudflare or Fastly and prove the gain with real-user monitoring, not a lab score.config ของ push ที่ตายแล้วยังค้างใน production ทั้งที่ browser เลิกสนใจไปนานแล้ว เปิด early hints ที่ Cloudflare หรือ Fastly แล้วพิสูจน์ผลด้วย real-user monitoring ไม่ใช่คะแนน lab

17 · TCP head-of-line blocking17 · TCP head-of-line blocking

One lost TCP packet freezes every HTTP/2 streamTCP packet หายตัวเดียว ทุก stream ของ HTTP/2 หยุดหมด

TCP byte stream pkt 1 · s1 pkt 2 · s3 pkt 3 · lost pkt 4 · s5 pkt 5 · s1 pkt 6 · s3 pkt 7 · s5 delivered to HTTP/2 arrived, but held until packet 3 is retransmitted — streams 1, 3 and 5 all wait HTTP/1.1 on six connections recovers each loss independently; HTTP/2 on one connection cannot

What it isคืออะไร

TCP delivers bytes in strict order. HTTP/2 multiplexes streams over one TCP connection, but TCP sees a single byte sequence and knows nothing about streams, so one lost packet holds back data for every stream even if it already arrived. On lossy networks HTTP/2 on one connection can perform worse than HTTP/1.1 on six, because each connection recovers from loss on its own.TCP ส่ง byte ตามลำดับเคร่งครัด HTTP/2 เอาหลาย stream มา multiplex บน TCP connection เดียว แต่ TCP เห็นแค่ลำดับ byte เส้นเดียว ไม่รู้จัก stream packet หายตัวเดียวเลยดึงข้อมูลของทุก stream ไว้ แม้มาถึงแล้วก็ตาม บน network ที่ packet หล่นบ่อย HTTP/2 บน connection เดียวอาจแย่กว่า HTTP/1.1 บน 6 เส้น เพราะแต่ละ connection กู้ loss แยกกัน

Analogy

One conveyor belt at a sorting depot: drop a box and everything behind it stops, even parcels that have nothing to do with each other.สายพานเส้นเดียวในศูนย์คัดแยก กล่องตกไปใบเดียว ของข้างหลังหยุดหมด แม้พัสดุพวกนั้นไม่เกี่ยวกันเลย

Why it mattersทำไมสำคัญ

This single property is the entire reason HTTP/3 exists. Confirm retransmits with ss -i and capture the stall itself with tcpdump. QUIC over UDP replaces the transport rather than working around it.คุณสมบัติข้อเดียวนี้คือเหตุผลทั้งหมดที่ HTTP/3 เกิดขึ้น ยืนยัน retransmit ด้วย ss -i และจับช่วงค้างด้วย tcpdump QUIC บน UDP เปลี่ยนตัว transport เลย แทนที่จะหาทางอ้อม

18–23 · In the paid section18–23 · อยู่ในส่วนเสียเงิน

Six more concepts sit behind the newsletter’s paywallอีก 6 แนวคิดอยู่หลัง paywall ของ newsletter

18

QUIC over UDP

HTTP/3’s transport: encryption, streams and loss recovery rebuilt on UDPtransport ของ HTTP/3: เข้ารหัส, stream และการกู้ loss สร้างใหม่บน UDP

19

QUIC handshake

Transport and TLS 1.3 negotiate together: 1 RTT to connect, 0-RTT on returntransport กับ TLS 1.3 เจรจาพร้อมกัน: เชื่อมต่อใน 1 RTT และ 0-RTT เมื่อกลับมาใหม่

20

Independent streams & loss recovery

A lost packet stalls only the stream it belongs to, not the whole connectionpacket หายกระทบเฉพาะ stream ที่มันอยู่ ไม่ใช่ทั้ง connection

21

Connection IDs & migration

Connections keyed by an ID, not IP and port: Wi-Fi to cellular without reconnectingconnection ระบุด้วย ID ไม่ใช่ IP กับ port สลับจาก Wi-Fi ไป cellular ได้โดยไม่ต้องต่อใหม่

22

QPACK

HPACK’s idea rebuilt so headers can arrive out of order without blockingไอเดียของ HPACK ที่สร้างใหม่ให้ header มาไม่เรียงลำดับได้โดยไม่บล็อก

23

Alt-Svc & HTTPS DNS records

How clients learn HTTP/3 exists: an Alt-Svc header, or an HTTPS record in DNSวิธีที่ client รู้ว่ามี HTTP/3: ผ่าน Alt-Svc header หรือ HTTPS record ใน DNS

The one-line glosses are general background (RFC 9000, 9001, 9114, 9204, 9460), not the article’s own textคำอธิบายบรรทัดเดียวเป็นความรู้ทั่วไป (RFC 9000, 9001, 9114, 9204, 9460) ไม่ใช่เนื้อหาจากบทความ

Summaryสรุป

Three protocols, one fight against the queue3 โปรโตคอล กับการสู้กับคิวเรื่องเดียว

1

HTTP/1.1: one in-order queue per connection. Keep-alive, six lanes and sharding only hide it.HTTP/1.1: คิวเรียงลำดับหนึ่งคิวต่อ connection keep-alive, 6 เลน และ sharding แค่ซ่อนมันไว้

2

HTTP/2: binary frames, multiplexing, HPACK, flow control and priorities remove the HTTP queue, but one lost TCP packet still stalls every stream.HTTP/2: binary frame, multiplexing, HPACK, flow control และ priority ถอดคิวของ HTTP ออก แต่ TCP packet หายตัวเดียวก็ยังหยุดทุก stream

3

HTTP/3: QUIC over UDP gives each stream its own loss recovery, a combined handshake and connection migration — the part of the article behind the paywall.HTTP/3: QUIC บน UDP ให้แต่ละ stream กู้ loss แยกกัน รวม handshake และย้าย connection ได้ ซึ่งเป็นส่วนของบทความที่อยู่หลัง paywall

Sourcesแหล่งอ้างอิง

Part 1: newsletter.systemdesign.one/p/http-concepts-explained · Part 2: newsletter.systemdesign.one/p/http2-vs-http3-explained (Neo Kim, Oct 2026)Part 1: newsletter.systemdesign.one/p/http-concepts-explained · Part 2: newsletter.systemdesign.one/p/http2-vs-http3-explained (Neo Kim, ตุลาคม 2026)

RFC 9110 · 9111 · 9112 (HTTP/1.1) · 9113 (HTTP/2) · 7541 (HPACK) · 9218 (priorities) · 8297 (early hints) · 9000 (QUIC) · 9114 (HTTP/3) · 9204 (QPACK)