Shin

My codepen account -

[Curious Minds @CuriousMindsHub]

How to remember everything you read

[Reads with Ravi @readswithravi]

“I lived so carefully, thinking someone was watching. But the stage was empty, the audience never came.”

— Osamu Dazai

[Vivek Galatage @vivekgalatage]

The performance treasure!

https://t.co/8e2liguze4

[Abhishek Singh @0xlelouch_]

90% of distributed systems work in 2026 comes down to mastering these 10 concepts:

1) Timeouts + retries + jitter
Retries without caps create self-inflicted DDoS; set per-hop budgets and add backoff with randomness.

2) Idempotency + dedupe
Assume at-least-once delivery; use idempotency keys, request hashing, and consumer-side dedup tables.

3) Backpressure
Queues hide pain until they explode; enforce limits (max in-flight, rate limits) and shed load intentionally.

4) Consistency choices
Strong vs eventual is a product decision; define read-your-writes, staleness windows, and conflict rules.

5) Partitioning and hot keys
Most outages are one partition at 10x traffic; detect skew, salt keys, and plan rebalancing.

6) Distributed locks and leases
Locks fail in weird ways; prefer leases with fencing tokens over infinite locks and clock assumptions.

7) Schema + contract evolution
Breaking changes happen at the edges; version messages, use compatibility tests, and deploy readers before writers.

8) Observability that joins dots
Metrics tell you it’s broken; traces + structured logs with stable IDs tell you where and why.

9) Debugging tools in prod
You need pprof/flamegraphs, live log sampling, and safe feature flags, not more dashboards.

10) Security primitives, not checklists
mTLS, least-privilege IAM, secret rotation, and audit logs; the common mistake is one shared role per cluster

[Polymath Investor @polymathinvest1]

A short manual on how to systematically increase your exposure to opportunity.
(1/2)

[Gergely Orosz @GergelyOrosz]

What can us, engineers else learn from designers and design engineers? Turns out there’s lots, based on talking with one of the best design engineers in the industry, @Mappletons.

Timestamps:

00:00 Intro
03:24 From anthropology to tech
10:18 What does a designer do?
18:23 How Maggie works
24:55 The case for planning with physical tools
31:53 Why Maggie is learning woodworking
33:13 Design engineers and engineering constraints
38:49 How Maggie uses Figma
40:30 Design at GitHub Next
45:12 How has AI changed design
50:37 When models design and why humans are still needed
53:30 UX and UI
58:29 Capability gaslighting
1:00:33 One Developer, Two Dozen Agents, Zero Alignment
1:07:21 Craft and AI tells
1:14:17 Visual gardens, home-cooked software, and barefoot developers
1:21:02 Advice for engineers and lessons from anthropology
1:25:34 Book recommendation

Brought to you by:

• @turbopuffer – a vector and full-text search engine built on object storage. It’s fast, cheap, and extremely scalable. https://t.co/w9y67GsFZJ

• @AntithesisHQ – verify your system’s correctness without human review or traditional integration tests – and avoid bugs or outages. https://t.co/AKYm4cctss

• @EntireHQ – every agent prompt, tool call, stored in your repo, and mirrored. Set up with one click: https://t.co/7yHVse7Nfq

Hope you enjoy this unusually visual episode - thanks again, Maggie!

[Kirk Borne @KirkDBorne]

System Design Interview Notes — Comprehensive Insider's Guide — 28 chapters, and more:
https://t.co/XMOxxGxsgi

[Ivan Velichko @iximiuz]

Networking 101: Port Forwarding 🧙‍♂️

Port forwarding, a.k.a. port mapping, is a networking trick that redirects packets from one address to another without changing either the sender or the receiver.

Technically, it is a form of Network Address Translation (NAT), and there are multiple ways to implement it. Practice forwarding ports using:

- socat: https://t.co/BMJ4tflgpL
- netcat: https://t.co/ANRAQITrvP
- without using a proxy process at all: https://t.co/GphEAaEHxS

Happy hacking!

[Ben Dicken @BenjDicken]

The right index all depends on 1) the structure of your data and 2) the queries.

Inverted indexes are The Choice™ for text search, but they are not all created equal!

A little dive into schema, point selects, and text search from last week's stream.

[BURKOV @burkov]

The "High-Level System Design Handbook" by Aayush Soni (2026) is now in @ChapterPal's collection of free books.

The book is a comprehensive guide intended for software engineers, system architects, and technical leaders who design, scale, and maintain large-scale distributed platforms or prepare for technical design interviews.

The text assumes a baseline familiarity with programming, basic operating system mechanics such as processes and threads, fundamental data structures, relational database concepts, and networking protocols such as TCP and HTTP.

From this foundation, the book covers the full architectural lifecycle of distributed software, ranging from single-machine performance limits to planet-scale multi-region topologies and modern artificial intelligence platforms.

Read the book with an AI tutor: https://t.co/X4DoA3zeeS

All book on ChapterPal are free to read with a free account.

The table of contents:

Here’s the ToC with all level-three headings removed.

Chapter 0: Prerequisites

* 0.0 Networking Fundamentals for System Design
* 0.1 Operating System Essentials for System Design
* 0.2 Data Structures for Distributed Systems
* 0.3 Database Fundamentals for System Design
* 0.4 API Design Basics: REST, GraphQL, gRPC, and the Hard Parts
* References

Chapter 1: Core Fundamentals

* 1.0 Scalability: Growing a System Without Breaking It
* 1.1 Latency and Throughput: The Two Numbers That Matter
* 1.2 Availability and Reliability: Nines, SLOs, and Staying Up
* 1.3 Consistency Models: What Readers Actually See
* 1.4 Back-of-the-Envelope Estimation
* 1.5 How to Approach a System Design Question
* 1.6 Trade-off Thinking
* References

Chapter 2: Building Blocks

* 2.0 Load Balancers: Spreading Traffic, Absorbing Failure
* 2.1 Reverse Proxies and API Gateways: The Smart Edge
* 2.2 Content Delivery Networks: Moving Bytes Closer to Users
* 2.3 Caching: From Browser to Database
* 2.4 SQL Databases: The Boring Technology That Wins
* 2.5 NoSQL Databases: Picking the Right Non-Relational Tool
* 2.6 Database Partitioning and Sharding: When One Node Is Not Enough
* 2.7 Database Replication: Keeping Copies in Sync
* 2.8 Message Queues and Streaming: Decoupling at Scale
* 2.9 Pub/Sub: Fan-Out and Event-Driven Systems
* 2.10 Real-Time Communication: WebSockets, SSE, and Long Polling
* 2.11 Rate Limiting: Protecting Systems from Themselves
* 2.12 Service Discovery and Service Mesh: Finding and Talking to Services
* 2.13 Blob and Object Storage: Storing the Big Stuff
* 2.14 Geospatial Indexing: Geohash, Quadtree, R-tree, S2, and H3
* 2.15 Edge Computing (Cloudflare Workers, Lambda@Edge, Deno Deploy)
* References

Chapter 3: Distributed Systems Theory

* 3.0 Consensus Protocols: How Distributed Systems Agree
* 3.1 Consistency Deep Dive: Linearizability, Serializability, and the Spectrum Between
* 3.2 Quorums and Replication: The Math of R + W > N
* 3.3 CAP and PACELC: The Tradeoff That Keeps Confusing People
* 3.4 Clocks and Ordering: Lamport, Vector, and Hybrid Logical Clocks
* 3.5 CRDTs: Conflict-Free Replicated Data Types
* 3.6 Distributed Transactions: 2PC, Saga, and When to Avoid Both
* 3.7 Idempotency and Exactly-Once: The Honest Truth About Delivery Guarantees
* 3.8 Failure Detection: Deciding a Node Is Dead
* 3.9 Consistent Hashing: Keys to Nodes Without Global Reshuffles
* 3.10 Merkle Trees and Anti-Entropy: Keeping Replicas in Sync Cheaply
* References

Chapter 4: Data Systems

* 4.0 Storage Engines: B-Trees, LSM-Trees, and Why Your Database Feels the Way It Does
* 4.1 OLTP vs OLAP: Row Stores, Column Stores, and Matching Shape to Workload
* 4.2 Data Warehouses and Data Lakes: Structure, Schema, and the Lakehouse
* 4.3 Stream vs Batch Processing: Lambda, Kappa, and the End of That Debate
* 4.4 Change Data Capture: Streaming the Database's Inner Monologue
* 4.5 Search Systems: Inverted Indexes, BM25, and Running Elasticsearch in Production
* 4.6 Time-Series Databases: Metrics, Events, and Retention at Scale
* 4.7 Graph Databases: Property Graphs, Cypher, and When Joins Are the Problem
* 4.8 Vector Databases: Embeddings, ANN Indexes, and the Retrieval Layer for AI
* 4.9 Key-Value Stores: Redis, Memcached, DynamoDB, and Picking the Right Hash Table
* References

Chapter 5: Architecture Patterns

* 5.0 Monolith vs Microservices: Team Topology, Conway's Law, and the Distributed System Tax
* 5.1 Event-Driven Architecture: Notifications, State Transfer, and Choreography
* 5.2 CQRS: Separating Reads from Writes Without Losing Your Mind
* 5.3 Event Sourcing: Events as the Source of Truth
* 5.4 Serverless: Functions, Cold Starts, and When FaaS Actually Saves Money
* 5.5 Backend for Frontend: Per-Client API Aggregation Done Right
* 5.6 Strangler Fig: Incremental Migration Without a Big Bang
* 5.7 Hexagonal and Clean Architecture: Keeping Business Logic Independent
* 5.8 Multi-Region Architecture: Active-Passive, Active-Active, and CRDTs
* 5.9 Multi-Tenancy: Silo, Pool, and the SaaS Isolation Spectrum
* 5.10 CRDT Applications (Yjs, Automerge, Local-First Software)
* References

Chapter 6: Reliability & Operations

* 6.0 Observability: Metrics, Logs, Traces, and the OpenTelemetry Standard
* 6.1 SLI, SLO, SLA, and Error Budgets: Making Reliability Quantitative
* 6.2 Resilience Patterns: Timeouts, Retries, Circuit Breakers, and Bulkheads
* 6.3 Graceful Degradation: When Partial Service Beats No Service
* 6.4 Auto-Scaling and Capacity Planning: From HPA to Predictive Scaling
* 6.5 Deployment Strategies: Blue-Green, Canary, Rolling, and Feature Flags
* 6.6 Chaos Engineering: Breaking Things on Purpose
* 6.7 Incident Management: From Detection to Blameless Postmortem
* 6.8 Health Checks and Readiness: Telling the Truth About Whether You're Up
* 6.9 Cost Optimization and FinOps
* 6.10 Platform Engineering: IDPs, Golden Paths, and DX
* References

Chapter 7: Security at Scale

* 7.0 Authentication vs Authorization: Identity, Permissions, and Access Models
* 7.1 OAuth 2.0 and OpenID Connect: Delegated Authorization and Identity Done Right
* 7.2 JWT Deep Dive: Signed Tokens, Claims, and the Revocation Problem
* 7.3 mTLS and Service-to-Service Authentication: SPIFFE, Service Mesh, and Zero Trust
* 7.4 Secrets Management: Vault, KMS, and the End of Secrets in Config Files
* 7.5 DDoS Protection and WAFs: Mitigating Volumetric and Application Attacks
* 7.6 Data Residency and Compliance Architecture (GDPR, DPDP, CCPA, Right-to-Erasure)
* 7.7 Supply Chain Security: SBOM, SLSA, Sigstore, and Defending Against xz-utils
* 7.8 Privacy-Preserving Systems (Differential Privacy, Federated Learning)
* 7.9 Post-Quantum Cryptography: Migrating to ML-KEM, ML-DSA, and a Crypto-Agile Future
* References

Chapter 8: Case Studies

* 8.0 Design a URL Shortener (TinyURL / https://t.co/SVd0hVZg9K)
* 8.1 Design a Pastebin (Paste Sharing Service)
* 8.2 Design a Distributed Rate Limiter
* 8.3 Design a Distributed Key-Value Store (Dynamo / Cassandra / Riak)
* 8.4 Design a Notification System (Push, SMS, Email at Scale)
* 8.5 Design a Chat System (WhatsApp / Messenger / Signal)
* 8.6 Design a Social Media Feed (Twitter / Instagram / LinkedIn)
* 8.7 Design a Photo Sharing Service (Instagram)
* 8.8 Design a Web Crawler (Googlebot-style)
* 8.9 Design Search Autocomplete (Typeahead Suggestions)
* 8.10 Design a Video Streaming Service (YouTube / Twitch / TikTok)
* 8.11 Design Netflix (End-to-End)
* 8.12 Design a Ride-Hailing Service (Uber / Lyft)
* 8.13 Design Google Maps (Routing and Tile Rendering)
* 8.14 Design a File Sync Service (Dropbox / Google Drive)
* 8.15 Design Collaborative Editing (Google Docs / Figma / Notion)
* 8.16 Design a Distributed Cache (Memcached / Redis Cluster)
* 8.17 Design a Recommendation System (Netflix / YouTube / TikTok)
* 8.18 Design a Ticketing System (BookMyShow / Ticketmaster)
* 8.19 Design a Payment System (Stripe / PayPal)
* 8.20 Design a Stock Exchange (Matching Engine)
* 8.21 Design a Food Delivery Service (DoorDash / Swiggy)
* 8.22 Design a Metrics Pipeline (Prometheus / InfluxDB / Thanos)
* 8.23 Design Ad-Click Aggregation (Real-Time Stream Processing)
* 8.24 Design a Logging Platform (ELK / Loki / Splunk)
* 8.25 Design a Proximity Service (Nearby Friends / Yelp)
* 8.26 Design a Real-Time Leaderboard
* 8.27 Design a Unique ID Generator (Snowflake, ULID, TSID, UUIDv7)
* 8.28 Design a Hotel Reservation System (https://t.co/SACYXzzUX0 / Airbnb)
* 8.29 Design a Distributed Job Scheduler (Airflow / Temporal / Distributed Cron)
* 8.30 Design ChatGPT (Conversational AI at Scale)
* 8.31 Design an Enterprise RAG System
* 8.32 Design a Coding Agent (Claude Code / GitHub Copilot / Cursor)
* 8.33 Design Perplexity (AI Search with Citations)
* 8.34 Design a Voice Agent (Alexa / Siri-Class Realtime)
* 8.35 Design a Content Moderation System at Scale
* 8.36 Design a Semantic Cache for LLM Applications
* 8.37 Design a Model Router and Gateway (OpenRouter / LiteLLM)
* 8.38 Design a Feature Flag Service (LaunchDarkly / Harness FME / Unleash)
* 8.39 Design a DNS Service (Cloudflare 1.1.1.1 / Google 8.8.8.8)
* 8.40 Design a Dating App (Tinder / Hinge / Bumble)
* 8.41 Design an Online Auction (eBay / Catawiki)
* 8.42 Design a Multi-Tenant SaaS Platform
* 8.43 Design a Video Conferencing System (Zoom / Google Meet)
* 8.44 Design an Email Service at Gmail Scale (1.8B Users, 300B Messages/Day)
* 8.45 Design Live Comments at Scale (FB Live / YouTube Live / Twitch Chat)
* 8.46 Design a Fraud Detection System (Stripe Radar / PayPal / Feedzai)
* 8.47 Design a Fitness Tracking Service (Strava / MapMyRun)
* 8.48 Design an Online Judge (LeetCode / Codeforces / HackerEarth)
* 8.49 Design a Price Tracking Service (CamelCamelCamel / Honey / Keepa)
* 8.50 Design an API Gateway at Scale (Kong / AWS API Gateway / Apigee / Envoy)
* 8.51 Design a CI/CD Platform (GitHub Actions / GitLab CI / CircleCI)
* 8.52 Design an Observability Platform (Datadog / New Relic / Honeycomb)
* 8.53 Design a Search Engine (Google-Scale / Brave Search)
* 8.54 Design a Brokerage Platform (Robinhood / E*TRADE / Interactive Brokers)
* 8.55 Design Channel-Scale Chat (Discord / Slack)
* References

Chapter 9: AI & ML System Design

* 9.0 LLM Serving Architecture (vLLM, TGI, TensorRT-LLM)
* 9.1 RAG Pipelines (Retrieval-Augmented Generation)
* 9.2 Vector Search at Scale (HNSW, IVF-PQ, DiskANN)
* 9.3 AI Agent Architectures (ReAct, Reflection, Planning, Tool Use, Memory)
* 9.4 Multi-Agent Orchestration (LangGraph, OpenAI Agents SDK, AutoGen, Swarm)
* 9.5 LLM Evaluation and Observability (Ragas, LangSmith, TruLens, LLM-as-Judge)
* 9.6 LLMOps and Prompt Engineering (Versioning, Guardrails, Red-Teaming)
* 9.7 LLM Cost Optimisation (Semantic Cache, Model Routing, Cascading, Prompt Caching)
* 9.8 LLM Safety and Guardrails (OWASP LLM Top 10, Prompt Injection, PII, Jailbreaks)
* 9.9 ML System Design Fundamentals
* 9.10 Feature Stores and Model Serving (Feast, Tecton, KServe, BentoML, MLflow)
* 9.11 Recommendation Systems Deep Dive (DLRM, Two-Tower, Embedding Retrieval, Cold Start)
* 9.12 Realtime AI and Voice Agents (Streaming Inference, WebRTC, LiveKit, Deepgram)
* 9.13 Multimodal AI Systems (CLIP, Whisper, LayoutLM, Document AI)
* 9.14 Data Infrastructure for AI (Embedding Pipelines, Chunking, Unstructured ETL, MCP)
* References

Chapter 10: Emerging Patterns

* 10.0 Green Computing (Carbon-Aware Scheduling, PUE, Sustainable Systems)
* References

Chapter 11: Interview Framework

* 11.0 Interview Frameworks Compared (RESHADED, PEDALS, ADEPT)
* 11.1 Requirements Scoping: Functional, Non-Functional, and MoSCoW
* 11.2 Diagramming Skills for System Design Interviews
* 11.3 Trade-off Articulation: Saying 'It Depends' Well
* 11.4 Company-Specific Interview Flavors (Amazon, Google, Meta, Netflix)
* 11.5 Design Doc Authoring: RFCs, ADRs, and the Staff Engineer's Written Output
* References

Trade-offs Library

* 1. Strong vs Eventual Consistency
* 2. ACID vs BASE
* 3. SQL vs NoSQL
* 4. Latency vs Throughput
* 5. CAP and PACELC Applied
* 6. Cache Strategies: Cache-Aside vs Write-Through vs Write-Behind
* 7. Batch vs Stream Processing
* 8. Load Balancer vs Reverse Proxy vs API Gateway
* 9. REST vs gRPC vs GraphQL
* 10. Polling vs Long-Polling vs SSE vs WebSockets vs Webhooks
* 11. Rate Limiting Algorithms: Token Bucket vs Sliding Window
* 12. Optimistic vs Pessimistic Concurrency Control
* 13. Partitioning Schemes: Range, Hash, Consistent Hash, Directory
* 14. B-tree vs LSM-tree Storage
* 15. Monolith vs Microservices
* 16. Replication Topologies: Leader-Follower, Multi-Leader, Leaderless
* 17. Distributed Transactions: 2PC vs Saga vs TCC
* 18. Push vs Pull (Fan-out, Messaging, Feed)
* 19. Lambda vs Kappa Architecture
* 20. Vertical vs Horizontal Scaling
* 21. Normalization vs Denormalization
* 22. Single-Region vs Multi-Region Deployment
* References

[Achilles @Xhej__]

you still have time to be great

[emma @emguoz]

Notion runs one of the largest CRDT deployments in production, processing millions of operations every minute!

We wrote about the data structures we adopted from CRDT research to make our text editor more collaborative, and how we built on those concepts to fit our block-based data model.

https://t.co/rNZtmmylu9

[Puneet Patwari @system_monarch]

Trust me, learning system is not hard. If you want to get GOAT-level good, start from these fundamental concepts:

This formed the foundations of the concepts I applied when I appeared for system design rounds at companies like: Amazon, Atlassian, Walmart, Saleforce, and Deliveroo.

1) Load Balancing: https://t.co/IytjJseO11

2) CDN: https://t.co/xxzUuwV5GD

3) Caching: https://t.co/QvyGIyKNHM

4) Cache Invalidation: https://t.co/FyDLJWZVOE

5) Rate Limiting: https://t.co/auDKgPpLeA

6) API Gateway: https://t.co/H1y0htWDub

7) CAP Theorem: https://t.co/AglSd993oa

8) Sharding: https://t.co/HT316hgoEr

9) Replication: https://t.co/NXessCjYp4

10) Partitioning: https://t.co/01bpFCZBhZ

11) Queues: https://t.co/Lenx1Pfw95

12) Microservices: https://t.co/Hx9Yn2yRBw

13) Microservices Vs Monoliths: https://t.co/g9lGFHydVj

14) Fault Tolerance: https://t.co/jCJk6d52z2

15) Database Scaling: https://t.co/h7pYha8x6x

16) Service Discovery: https://t.co/vEDMvhWYj5

17) Consistency models: https://t.co/cb3zNtdZNA

18) Eventual Consistency: https://t.co/aFjL3flHNY

19) Distributed Transactions: https://t.co/s0ZWdtTqiW

20) Leader Election: https://t.co/IxrWO9AvB3

21) Horizontal vs Vertical Scaling: https://t.co/I8CH64dL5l

22) Back of the Envelope Estimation: https://t.co/gyatcqpaqO

23) Idempotency, Data Latency & Finale: https://t.co/fNArLx4MrW

[DAN KOE @thedankoe]

https://t.co/LalU5XENsk

[Fatih Arslan @fatih]

My blog post about how I manage agents is finally ready. It first explains my bespoke `plans` setup, and then explains how @cursor_ai new Projects feature enabled me |o do so much more. It was the missing piece for me. Check it out:

https://t.co/TbIdJqxVGo

[Govardhana Miriyala Kannaiah @govardhana_mk]

25 Blogs to Learn 25 AWS Concepts:

1) API Gateway: https://t.co/twWpRwHnyu
2) Scaling Patterns: https://t.co/Ib3Fc0wecy
3) VPC Network Segmentation: https://t.co/ueOV6X19FJ
4) DR Strategies: https://t.co/YD3bErGMIv
5) Load Balancers: https://t.co/0nmxSPrAZD
6) Cross Zone Load Balancing: https://t.co/K6bcXQmikO
7) IAM Policies: https://t.co/aqtm7FytQo
8) EC2 Guide: https://t.co/Uyl6R70V3H
9) DNS Record Types: https://t.co/gS3sbhvaLn
10) DNS Policies: https://t.co/zhACVF5GpE
11) VPC Peering: https://t.co/IyTcYRnxVL
12) VPC Gateway Endpoints:https://t.co/g11GhZNdwC
13) Internet Gateway vs NAT Gateway: https://t.co/wC9x7qOxT3
14) 7Rs Cloud Migration: https://t.co/M2mtKSunz1
15) Lambda Integrations: https://t.co/jHa82Yy1nD
16) Lambda Cold Starts: https://t.co/qBZPogu4lk
17) Lambda Power Tuning: https://t.co/kA5Tbd4cIb
18) Data Transfer Costs: https://t.co/gRuscfAYEb
19) Hexagonal Architecture: https://t.co/JmpysdHPCg
20) GuardDuty: https://t.co/1wXehgQFUt
21) SSO: https://t.co/t5LtACmAnX
22) Signed vs Pre Signed URL: https://t.co/nim2INsAnn
23) Serverless Architecture: https://t.co/KeUOuudMuY
24) Cloud Cost Control: https://t.co/9IcCtqzsEW
25) Behind the Scenes of a Cloud App: https://t.co/YH22ianh8Y

50K+ read my DevOps and Cloud newsletter: https://t.co/WBucLdwdsb

What do we cover:
DevOps, Cloud, Kubernetes, IaC, GitOps, MLOps

🔁 Consider a repost if this is helpful.

[Hades @0xHvdes]

https://t.co/0OGMXzPyvf