Summary of "30+ Conceptos de System Design Que Todo Desarrollador Debe Dominar"

Overview

This video is a compact systems-design primer that explains ~30 core concepts every developer should know. Topics include networking basics, APIs/protocols, storage and databases, scaling and reliability patterns, architecture styles, and operational concerns. For each concept the video gives a simple definition, practical examples, common tools/services, and guidance on when and why to use each pattern. A sponsor (Cynote) and links/resources (previous videos, Discord, social media) are mentioned.

Key concepts (terms + one-line explanations)

Networking & protocols

Client‑server architecture: separation between client apps (browser, mobile, CLI) and server applications that receive requests and send responses.
IP addresses & DNS: numeric addressing (IPv4/IPv6) and human‑readable mapping via DNS servers; use tools like ping to inspect addresses.
HTTP / HTTPS: request/response protocol for the web; HTTPS adds encryption for secure transfer.
Proxies: forward proxy (clients hide behind a proxy) and reverse proxy (protect/orchestrate backend servers; often used for security/scaling).
Latency & regions: network round‑trip delays; choose cloud regions close to users to reduce latency.

APIs

API basics: API servers, REST (JSON), HTTP verbs (GET/POST/PUT), and alternatives (GraphQL, gRPC, tRPC, SOAP).
API Gateway: central entry point for microservices (routing, auth, rate limiting, orchestration).
Idempotency: ensure repeated requests have the same effect as a single request (important for payments/retries).
Rate limiting: protect APIs from abusive/bot traffic; algorithms include fixed window, sliding window, token bucket.

Databases & storage

Databases (SQL vs NoSQL): relational (Postgres, MySQL, Oracle, SQL Server) with structured tables and SQL; NoSQL (MongoDB, Redis, Cassandra, DynamoDB) with document, key‑value, graph, etc., for flexibility and horizontal scaling.
ACID properties: Atomicity, Consistency, Isolation, Durability—important for transaction guarantees.
Database scaling:
- Replication: primary + read replicas to improve read throughput and failover.
- Sharding (horizontal partitioning): split data across multiple nodes to scale writes and storage.
- Vertical partitioning: split wide tables into multiple tables to optimize queries.
Denormalization: duplicate data to avoid expensive joins and speed reads (trades storage and consistency complexity).
Blob (object) storage: store unstructured files (images, videos) outside the DB (AWS S3, Google Cloud Storage, DigitalOcean Spaces, Bunny.net); DB stores URLs/metadata.
Caching: store frequently accessed data in fast RAM stores (Redis, Memcached) to reduce DB load and latency.
CDN (Content Delivery Network): geographically distributed cache nodes to serve static content faster to users.

Scaling, reliability & distributed systems

Scaling:
- Vertical scaling: add CPU/RAM/disk to a single instance (limited ceiling, single point of failure).
- Horizontal scaling: add more smaller copies/instances (better fault tolerance, elastic cost).
Load balancer: distributes requests across instances; common algorithms: round‑robin, least‑connections, IP‑hash.
Message queues & asynchronous processing: decouple services with queues (producer -> queue -> consumer/worker) to avoid blocking and scale background work.
CAP theorem: consistency, availability, partition tolerance — tradeoffs for distributed systems (e.g., MySQL emphasizes consistency; Cassandra/DynamoDB favor availability/partition tolerance).

Architecture styles

Monolith vs Microservices: monolith = single app; microservices = small, focused services (independent deploys, per‑service DBs possible).
API styles & alternatives: REST, GraphQL, gRPC, tRPC, SOAP — different tradeoffs for design, performance, and client needs.

Tools, services and examples mentioned

Sponsor / deployment platform:

Cynote — GitHub/GitLab deploys, supports Node/Python/Go/Elixir, custom domains, automatic HTTPS, WebSockets, HTTP/2, real‑time logs, env vars, 24/7 support. Offers DBs (Postgres/MySQL) and backend servers at low prices; free 7‑day trial. (Video cites an example backend tier ≈ $4/month.)
Databases & storage: PostgreSQL, MySQL, Oracle, SQL Server, MongoDB, Redis, Cassandra, DynamoDB, Neo4j, SQLite.
Blob/object storage & CDN: AWS S3, Google Object Storage, DigitalOcean Spaces, Bunny.net; CDNs for distributed content delivery.
Caching alternatives: Redis, Memcached (and similar projects).
Miscellaneous: using ping in the terminal to get IPs; IPv4 vs IPv6 differences.

Mentions of tutorials, guides & community links

The presenter promises links in the video description for further reading and a previous video that compares API styles (REST vs GraphQL etc.).
Invitation to join a Discord community: fast.df/discord (also referenced as df/discord).
Social links referenced: Twitter, Instagram, TikTok, the main channel, and a website for booking personalized consultations (all referenced but not named in subtitles).

Main speakers / sources referenced

Video presenter / narrator (the channel’s host; not named in the subtitles).
Cynote (sponsor / deployment platform).
Referenced technologies and vendors used as examples across explanations: AWS, Google Cloud, DigitalOcean, Redis, MongoDB, Cassandra, DynamoDB, etc.

Optional follow-ups (offered in the video)

Produce a one‑page cheat sheet listing these concepts grouped by category.
Expand any single concept into a short tutorial (examples suggested: how to design read replicas, implement rate limiting, or set up caching with Redis).