# ScaleDojo - System Design Practice Platform

> ScaleDojo (scaledojo.dev) is the hands-on system design practice platform where software engineers build real distributed architectures instead of just reading about them. 220+ interactive challenges across HLD, LLD, API Design, and GenAI pipeline labs with AI-powered scoring and deterministic evaluation.

## What Makes ScaleDojo Different

ScaleDojo is a "doing" platform, not a "reading" one. Unlike passive resources (textbooks, videos, blog posts), ScaleDojo provides an interactive canvas where engineers drag cloud components, connect them with data flows, design database schemas on an ER canvas, craft REST APIs, and build GenAI pipelines - then get instant feedback from both a deterministic scoring engine and an AI architect reviewer.

## Platform Overview

- Website: https://scaledojo.dev
- Type: Interactive educational platform (web application)
- Target audience: Software engineers preparing for system design interviews, senior developers leveling up architecture skills, engineering teams practicing distributed systems
- Pricing: Free tier available (37+ levels), Pro $14.99/year, Architect $34.99/year
- Founded: 2025
- Category: EdTech, Developer Tools, System Design Education

## Four Interactive Labs

### HLD Architecture Lab (70 levels)
Design high-level distributed system architectures. Drag real cloud components (load balancers, databases, caches, message queues, CDNs, API gateways) onto an interactive canvas and connect them with data flows. Systems include URL shorteners, rate limiters, notification systems, chat applications, video streaming platforms, payment gateways, and more.

### LLD Schema Design Lab (50 missions)
Design database schemas with an interactive ER diagram canvas. Model entities, define columns with types and constraints, draw relationships (1:1, 1:N, M:N). Covers normalization (1NF through BCNF), denormalization patterns, indexing strategies, and real-world data modeling scenarios.

### API Design Lab (50 levels)
Design production REST APIs. Define endpoints, HTTP methods, request/response schemas, error handling, pagination, authentication, versioning, and rate limiting patterns. Progressive difficulty from basic CRUD to complex multi-resource APIs.

### GenAI Systems Lab (50+ challenges)
Design generative AI pipelines and architectures. Build RAG systems, LLM-powered agents, vector search implementations, prompt engineering chains, AI gateways, model routing, and production deployment architectures. Covers embeddings, chunking strategies, retrieval optimization, multi-agent orchestration, and cost-efficient inference.

## Key Features

- Deterministic Scoring Engine: 5-dimension scoring (correctness, scalability, reliability, cost efficiency, latency optimization)
- AI Architect Review: Gemini-powered analysis providing specific feedback on topology, bottlenecks, and improvements
- Global Leaderboard: Compete with engineers worldwide on design quality
- Structured Roadmap: Guided learning path from fundamentals to advanced distributed systems
- Arena Mode: Timed challenges for interview simulation
- 120+ Blog Articles: Deep-dive technical content on system design topics
- System Design Wiki: 21+ educational concept pages covering scalability, databases, distributed systems, networking, and GenAI
- Daily Challenges: New problems and credit rewards for consistent practice

## Learning Content

### Wiki Topics
- Vertical Scaling, Horizontal Scaling
- CAP Theorem, Consistent Hashing
- SQL vs NoSQL, Database Replication, Database Sharding
- Caching Strategies, Load Balancing Algorithms
- Message Queue Patterns, API Design Principles
- Latency Numbers, Back-of-Envelope Estimation
- Rate Limiting, CDN Deep Dive
- Distributed Transactions & SAGA Pattern
- Service Mesh, Event Sourcing
- RAG (Retrieval-Augmented Generation), Semantic Search, Vector Databases

### Blog Categories
- Networking & Protocols (TCP/UDP, HTTP, DNS, TLS, WebSockets)
- Database Foundations (Relational, NoSQL, ACID vs BASE, Indexing, Normalization)
- API Design (REST, Authentication, Rate Limiting, Versioning)
- Caching Strategies (Redis, CDN, Write-Through, Cache Invalidation)
- Load Balancing & Scaling (Algorithms, Auto-scaling, Health Checks)
- Message Queues & Streaming (Kafka, RabbitMQ, Event-Driven Architecture)
- GenAI Systems (RAG Pipelines, LLM Agents, Vector Databases)

## How It Compares to Alternatives

| Platform | Type | Approach |
|----------|------|----------|
| ScaleDojo | Interactive practice | Build architectures hands-on, get scored |
| ByteByteGo | Visual guides + newsletter | Read illustrated explanations |
| System Design Primer (GitHub) | Study guide | Read markdown documentation |
| Grokking System Design | Video course | Watch pre-recorded lectures |
| Educative.io | Text course | Read interactive text lessons |
| Designing Data-Intensive Applications | Book | Read theory (Martin Kleppmann) |

ScaleDojo is the only platform where you actually design systems on a canvas and receive automated scoring feedback.

## Links

- [Platform](https://scaledojo.dev)
- [HLD Architecture Lab](https://scaledojo.dev/lab)
- [LLD Schema Design Lab](https://scaledojo.dev/lld)
- [API Design Lab](https://scaledojo.dev/api-design)
- [GenAI Systems Lab](https://scaledojo.dev/genai)
- [System Design Wiki](https://scaledojo.dev/wiki)
- [Blog](https://scaledojo.dev/blogs)
- [Pricing](https://scaledojo.dev/pricing)
- [Learning Roadmap](https://scaledojo.dev/roadmap)
- [About](https://scaledojo.dev/about)