system-and-data-design

Featured

Decide whether the system will hold, and where the data lives: requirements and load first, then back-of-the-envelope numbers, building blocks (cache, queue, load balancer, CDN), and the data layer in depth — storage engines, indexes, replication, partitioning, transactions and consistency, batch vs stream. Use when sizing or scaling anything; choosing a database, cache, queue or index; when asked "will this hold", "how many machines", "which database", "do we need a queue", "read replica", "sharding", "eventual consistency", "why is this query slow at scale"; when designing an ingestion or processing pipeline; or when a service is slow under load rather than wrong. Do NOT use for module layout, dependency direction or domain boundaries (use architecture-first), for function- and naming-level quality (use code-complexity), for restructuring code that is already too large (use refactoring-safely), or for a low-traffic internal tool where the honest answer is one process and one database.

AI & Automation 150 stars 24 forks Updated 3 days ago MIT

Install

View on GitHub

Quality Score: 88/100

Stars 20%
73
Recency 20%
100
Frontmatter 20%
70
Documentation 15%
100
Issue Health 10%
50
License 10%
100
Description 5%
100

Skill Content

# System and data design — will it hold, and where does the data live Two questions that are usually asked together and answered separately, badly. Capacity without storage internals gives a diagram that cannot be built; storage internals without capacity gives a database choice with no reason behind it. ## Scope guard — read first The most common failure here is answering at the wrong scale. | Situation | Honest answer | |---|---| | Internal tool, tens of users | One process, one database, no cache. Stop. | | Product with real traffic, single region | Estimate first; add a cache and a queue only where the numbers say | | Multi-region, or data outgrowing one machine | Full pass: estimation → building blocks → replication/partitioning → consistency | Adding a cache before measuring is the canonical way to convert one problem into two. ## Step 1 — requirements before architecture - **Functional**: what must it actually do? Write it as verbs, not components. - **Non-functional, with numbers**: users, requests/sec at peak, payload size, growth, read:write ratio, acceptable latency, acceptable staleness, retention. - **Constraints**: budget, team size, existing stack, compliance, where data may live. "Acceptable staleness" is the single most useful number and the one nobody asks for. It decides caching, replication and consistency all at once. ## Step 2 — back-of-the-envelope, before any diagram Estimate storage/day, bandwidth at peak, QPS, and working-set size. The po...

Details

Author
AnastasiyaW
Repository
AnastasiyaW/codex-claude-code-config
Created
5 months ago
Last Updated
3 days ago
Language
Python
License
MIT

Bundled in these plugins

Similar Skills

Semantically similar based on skill content — not just same category

AI & Automation Featured

ddia-systems

Design data systems by understanding storage engines, replication, partitioning, transactions, and consistency models. Use when the user mentions "database choice", "which database should I use", "SQL or NoSQL", "replication lag", "partitioning strategy", "consistency vs availability", "stream processing", "ACID transactions", "eventual consistency", "my queries are slow at scale", or "data is inconsistent across replicas". Also trigger when choosing a datastore, designing data pipelines, or debugging distributed-system consistency issues. Covers data models, batch/stream processing, and distributed consensus. For system design, see system-design. For resilience, see release-it.

2,147 Updated today
wondelai
AI & Automation Listed

data-systems

Design, review, and evolve reliable data models, datastores, transactions, consistency contracts, replication, partitioning, batch or streaming flows, and data migrations. Use for database or event-model decisions, read and write guarantees, concurrent updates, dual-write risks, replication lag, sharding or partition-key choices, data-pipeline semantics, schema evolution, backfills, cutovers, and recovery planning. Start from observed access patterns, invariants, load, failure consequences, and operational capability; do not introduce distribution, polyglot persistence, or event sourcing without a concrete driver.

0 Updated 4 days ago
sebastian-software
AI & Automation Listed

system-design

End-to-end system design for real codebases and greenfield problems. Use when the user asks to design or architect a system, map or reverse-engineer an existing architecture, review a design doc/PR/ADR, plan a migration, scaling evolution or service split, choose technologies (SQL vs NoSQL, Kafka vs SQS, cache strategy, sharding), size infrastructure (servers, QPS, storage, cost), or practice system design interviews. Also fires on oblique asks such as "is Postgres enough?", "will this hold at 10x?", "should we split this service?", "write an ADR", "capacity plan for peak", "our DB falls over at peak". Covers capacity math, failure-mode stress testing, right-sizing against over-engineering, cost estimation, distributed-systems fundamentals, and LLM-era infrastructure (RAG, vector search, model serving). Produces ADR-style design docs with Mermaid diagrams, architecture maps, scored reviews, and migration plans. NOT for UI/visual/CSS/logo design, single-query database tuning, or DevOps pipeline debugging.

1 Updated 1 weeks ago
DAAS2