{"version":1,"courses":[{"id":"design","title":"System design","subtitle":"Build systems that scale","description":"From your first request to distributed storage, resilient services, and complete system designs.","order":1,"unitIds":["design-first-system","design-performance","design-storage","design-data-at-scale","design-fast-reads","design-service-interfaces","design-async-systems","design-resilient-services","design-production","design-secure-systems","design-design-lab","design-systems-in-the-wild"],"icon":"tree","color":"#4F46E5"},{"id":"coding","title":"Service code","subtitle":"The code behind the systems you design","description":"Write the components a real service is made of: the functions behind an endpoint, batching, API boundaries that hold, traffic control, safe state changes and a job worker that survives retries. Every exercise runs against executable tests. This is applied JavaScript — if the language itself is new, start with the JavaScript course.","order":2,"unitIds":["coding-service-functions","coding-collections","coding-api-boundaries","coding-traffic-control","coding-safe-state","coding-job-processing"],"icon":"code","color":"#16A34A"},{"id":"genai","title":"Generative AI","subtitle":"From LLMs to agent systems","description":"Understand models, build retrieval and agent systems, evaluate behavior, and operate AI in production.","order":3,"unitIds":["genai-llm-foundations","genai-prompt-and-tools","genai-retrieval","genai-agents","genai-model-serving","genai-model-adaptation","genai-vision-and-generation","genai-multimodal","genai-document-intelligence","genai-evaluation","genai-evaluation-domains","genai-safety","genai-ai-operations","genai-genai-design"],"icon":"sparkle","color":"#7C3AED"},{"id":"ml","title":"Machine learning","subtitle":"From data to production","description":"Frame an ML problem, build data and training pipelines, serve models, and keep them reliable.","order":4,"unitIds":["ml-ml-foundations","ml-data-and-features","ml-data-quality","ml-training","ml-ml-evaluation","ml-efficient-models","ml-ml-operations","ml-distributed-ml","ml-perception-and-language","ml-ml-applications","ml-ml-frontiers"],"icon":"insights","color":"#0EA5E9"},{"id":"python","title":"Python","subtitle":"Read and write real Python","description":"Eight units from your first print() to handling errors: variables, decisions, loops, lists, dictionaries, functions, strings and exceptions. Every exercise is real Python you predict, arrange, complete or debug on your phone.","order":5,"unitIds":["python-hello","python-decisions","python-repeating","python-collections","python-dicts","python-functions","python-strings","python-errors"],"icon":"braces","color":"#2B6CB0"},{"id":"javascript","title":"JavaScript","subtitle":"The language itself, from values to async","description":"Learn the language: values, functions, arrays, objects, control flow, strings, asynchrony and modern syntax. Read, predict and write it, with runnable drills. When you want to apply it to real service components, Service code picks up where this leaves off.","order":6,"unitIds":["javascript-values","javascript-functions","javascript-arrays","javascript-objects","javascript-control-flow","javascript-strings","javascript-async","javascript-modern"],"icon":"javascript","color":"#D97706"},{"id":"dsa","title":"Data Structures & Algorithms","subtitle":"Think in structures, reason about cost","description":"Trace arrays, maps, stacks, lists, recursion, trees and graphs on concrete inputs, count what they cost, then build each one in JavaScript.","order":7,"unitIds":["dsa-big-o","dsa-arrays","dsa-hash-maps","dsa-stacks-queues","dsa-linked-lists","dsa-recursion","dsa-trees","dsa-graphs"],"icon":"graph","color":"#DB2777"},{"id":"sql","title":"Databases & SQL","subtitle":"Ask data the right questions","description":"Six units from a single table to query plans: tables and rows, SELECT and WHERE, JOINs, GROUP BY and aggregates, indexes and plans, transactions and schema design. Every exercise is a real query you run in your head against rows on the screen.","order":8,"unitIds":["sql-tables","sql-select","sql-joins","sql-aggregates","sql-indexes","sql-transactions"],"icon":"table","color":"#0D9488"},{"id":"typescript","title":"TypeScript","subtitle":"JavaScript that tells you when you are wrong","description":"Add types to the JavaScript you already write: annotations and inference, interfaces, unions and narrowing, function signatures, generics, and the utility types that make real code readable. Every session is tap-to-answer, with runnable drills.","order":9,"unitIds":["typescript-types","typescript-objects","typescript-unions","typescript-functions","typescript-generics","typescript-practical"],"icon":"rule","color":"#1E40AF"},{"id":"web","title":"Web & APIs","subtitle":"How the web actually talks","description":"Six units from a single request to a retry budget: HTTP by hand, designing an API, JSON payloads, identity, the browser side, and what to do when it goes wrong. Every exercise puts a real request or response on the screen and asks what comes back.","order":10,"unitIds":["web-http","web-rest","web-json","web-auth","web-browser","web-reliability"],"icon":"globe","color":"#06B6D4"},{"id":"git","title":"Git & collaboration","subtitle":"Work with other people without fear","description":"Five units from your first commit to rescuing work you thought was gone: the staging area, branches as pointers, merging and rebasing, a shared remote, and the undo commands. Every exercise starts from a history sketch or a git status you can read on the screen.","order":11,"unitIds":["git-basics","git-branches","git-merging","git-remotes","git-recovery"],"icon":"branch","color":"#F05032"},{"id":"devops","title":"DevOps & Cloud","subtitle":"Ship it, run it, know when it breaks","description":"Six units from a Dockerfile to a cloud bill: what an image really is, what a pipeline runs and when, where configuration and secrets belong, how a deploy goes forward and back, which signal answers which question, and what you are actually paying for. Every exercise puts a real file, command or rollout on the screen and asks what happens.","order":12,"unitIds":["devops-containers","devops-pipelines","devops-config","devops-deploy","devops-observability","devops-cloud"],"icon":"cloud","color":"#65A30D"},{"id":"security","title":"Security","subtitle":"Think like the person attacking your code","description":"Six units on the weaknesses that put real applications on the front page: input that turns into code, passwords stored the wrong way, an ownership check nobody wrote, a script that runs in someone else's session, a key in the repository, and a dependency you never chose. Every exercise puts your own code on the screen and asks what is wrong with it and how to fix it.","order":13,"unitIds":["security-injection","security-authn","security-authz","security-web","security-secrets","security-supplychain"],"icon":"shield","color":"#334155"},{"id":"testing","title":"Testing & craft","subtitle":"Code you can change without fear","description":"Write tests that can fail for the right reason, choose the cases that matter, isolate what you cannot control, keep a suite you can live with, refactor safely, and review code like someone who has to maintain it. JavaScript throughout, tap-to-answer with runnable drills.","order":14,"unitIds":["testing-first","testing-cases","testing-doubles","testing-suites","testing-refactor","testing-review"],"icon":"checklist","color":"#78350F"}],"units":[{"id":"design-first-system","courseId":"design","order":1,"title":"Your first system","description":"Trace a request, scale a service, and put a cache in the read path.","sessionIds":["request-journey","scale-a-service","cache-a-read","checkpoint-design-first-system"],"checkpointSessionId":"checkpoint-design-first-system","placementSessionIds":["checkpoint-design-first-system"],"prerequisites":[],"skillIds":["skill-request-journey","skill-scale-a-service","skill-cache-a-read"],"revision":"6cefe6fdd870"},{"id":"design-performance","courseId":"design","order":2,"title":"Reason about performance","description":"Measure what users experience and find the constraint that actually matters.","sessionIds":["lesson-latency-vs-throughput","lesson-performance-metrics","lesson-bottleneck-analysis","lesson-advanced-scaling","lesson-reliability-availability","checkpoint-design-performance"],"checkpointSessionId":"checkpoint-design-performance","placementSessionIds":["checkpoint-design-performance"],"prerequisites":["design-first-system"],"skillIds":["skill-lesson-latency-vs-throughput","skill-lesson-performance-metrics","skill-lesson-bottleneck-analysis","skill-lesson-advanced-scaling","skill-lesson-reliability-availability"],"revision":"db1a787c330c"},{"id":"design-storage","courseId":"design","order":3,"title":"Store data correctly","description":"Choose a data model and protect the facts your application cannot lose.","sessionIds":["lesson-database-fundamentals","lesson-data-modeling","lesson-acid-properties","lesson-mysql","lesson-postgresql","lesson-mongodb","checkpoint-design-storage"],"checkpointSessionId":"checkpoint-design-storage","placementSessionIds":["checkpoint-design-storage"],"prerequisites":["design-performance"],"skillIds":["skill-lesson-database-fundamentals","skill-lesson-data-modeling","skill-lesson-acid-properties","skill-lesson-mysql","skill-lesson-postgresql","skill-lesson-mongodb"],"revision":"fa3c8db776ee"},{"id":"design-data-at-scale","courseId":"design","order":4,"title":"Data at scale","description":"Understand partitioning, replication, and the storage structures behind a database.","sessionIds":["lesson-replication-sharding","lesson-consistent-hashing","lesson-sstable","lesson-cassandra","lesson-dynamodb","checkpoint-design-data-at-scale"],"checkpointSessionId":"checkpoint-design-data-at-scale","placementSessionIds":["checkpoint-design-data-at-scale"],"prerequisites":["design-storage"],"skillIds":["skill-lesson-replication-sharding","skill-lesson-consistent-hashing","skill-lesson-sstable","skill-lesson-cassandra","skill-lesson-dynamodb"],"revision":"04a73772fe5a"},{"id":"design-fast-reads","courseId":"design","order":5,"title":"Make reads fast","description":"Design cache behavior, search indexes, and content delivery around the workload.","sessionIds":["lesson-redis","lesson-memcached","lesson-elasticsearch","lesson-lucene","lesson-object-storage","lesson-cloudfront","checkpoint-design-fast-reads"],"checkpointSessionId":"checkpoint-design-fast-reads","placementSessionIds":["checkpoint-design-fast-reads"],"prerequisites":["design-data-at-scale"],"skillIds":["skill-lesson-redis","skill-lesson-memcached","skill-lesson-elasticsearch","skill-lesson-lucene","skill-lesson-object-storage","skill-lesson-cloudfront"],"revision":"741235279312"},{"id":"design-service-interfaces","courseId":"design","order":6,"title":"Connect services","description":"Design APIs and choose how services exchange requests and streams.","sessionIds":["lesson-api-design","lesson-api-paradigms","lesson-graphql","lesson-grpc","lesson-websocket","lesson-http2-http3","checkpoint-design-service-interfaces"],"checkpointSessionId":"checkpoint-design-service-interfaces","placementSessionIds":["checkpoint-design-service-interfaces"],"prerequisites":["design-fast-reads"],"skillIds":["skill-lesson-api-design","skill-lesson-api-paradigms","skill-lesson-graphql","skill-lesson-grpc","skill-lesson-websocket","skill-lesson-http2-http3"],"revision":"7433a1c376b6"},{"id":"design-async-systems","courseId":"design","order":7,"title":"Asynchronous systems","description":"Decouple work with queues, event streams, and durable workflows.","sessionIds":["lesson-communication-patterns","lesson-fundamentals-message-queues","lesson-kafka","lesson-rabbitmq","lesson-sqs","lesson-event-driven-architecture","lesson-temporal","checkpoint-design-async-systems"],"checkpointSessionId":"checkpoint-design-async-systems","placementSessionIds":["checkpoint-design-async-systems"],"prerequisites":["design-service-interfaces"],"skillIds":["skill-lesson-communication-patterns","skill-lesson-fundamentals-message-queues","skill-lesson-kafka","skill-lesson-rabbitmq","skill-lesson-sqs","skill-lesson-event-driven-architecture","skill-lesson-temporal"],"revision":"a9c10ed8cd41"},{"id":"design-resilient-services","courseId":"design","order":8,"title":"Keep services running","description":"Control overload, contain failures, and make recovery a design decision.","sessionIds":["lesson-nginx","lesson-proxies-load-balancing","lesson-rate-limiting-tech","lesson-circuit-breakers","lesson-concurrency","lesson-chaos-engineering","checkpoint-design-resilient-services"],"checkpointSessionId":"checkpoint-design-resilient-services","placementSessionIds":["checkpoint-design-resilient-services"],"prerequisites":["design-async-systems"],"skillIds":["skill-lesson-nginx","skill-lesson-proxies-load-balancing","skill-lesson-rate-limiting-tech","skill-lesson-circuit-breakers","skill-lesson-concurrency","skill-lesson-chaos-engineering"],"revision":"14be68f2c5db"},{"id":"design-production","courseId":"design","order":9,"title":"Ship and operate","description":"Package services, coordinate a cluster, and observe the system in production.","sessionIds":["lesson-monolith-to-microservices","lesson-docker","lesson-kubernetes","lesson-etcd","lesson-prometheus","lesson-grafana","checkpoint-design-production"],"checkpointSessionId":"checkpoint-design-production","placementSessionIds":["checkpoint-design-production"],"prerequisites":["design-resilient-services"],"skillIds":["skill-lesson-monolith-to-microservices","skill-lesson-docker","skill-lesson-kubernetes","skill-lesson-etcd","skill-lesson-prometheus","skill-lesson-grafana"],"revision":"d9cf1bea552c"},{"id":"design-secure-systems","courseId":"design","order":10,"title":"Protect the system","description":"Build secure boundaries for identity, credentials, and application traffic.","sessionIds":["lesson-oauth2","lesson-jwt","lesson-keycloak","lesson-vault","lesson-advanced-web-security","checkpoint-design-secure-systems"],"checkpointSessionId":"checkpoint-design-secure-systems","placementSessionIds":["checkpoint-design-secure-systems"],"prerequisites":["design-production"],"skillIds":["skill-lesson-oauth2","skill-lesson-jwt","skill-lesson-keycloak","skill-lesson-vault","skill-lesson-advanced-web-security"],"revision":"ec46e46b38de"},{"id":"design-design-lab","courseId":"design","order":11,"title":"Design complete services","description":"Apply the building blocks to end-to-end design problems.","sessionIds":["lesson-system-design-framework","lesson-practice-url-shortener","lesson-practice-chat-system","lesson-practice-distributed-cache","lesson-practice-payment-system","lesson-practice-notification-system","checkpoint-design-design-lab"],"checkpointSessionId":"checkpoint-design-design-lab","placementSessionIds":["checkpoint-design-design-lab"],"prerequisites":["design-secure-systems"],"skillIds":["skill-lesson-system-design-framework","skill-lesson-practice-url-shortener","skill-lesson-practice-chat-system","skill-lesson-practice-distributed-cache","skill-lesson-practice-payment-system","skill-lesson-practice-notification-system"],"revision":"5e3f3aa368d9"},{"id":"design-systems-in-the-wild","courseId":"design","order":12,"title":"Learn from real systems","description":"Compare architectural choices in messaging, streaming, collaboration, and transport.","sessionIds":["lesson-case-study-whatsapp-messaging","lesson-case-study-netflix-streaming","lesson-case-study-github-collaboration","lesson-case-study-uber-ridesharing","checkpoint-design-systems-in-the-wild"],"checkpointSessionId":"checkpoint-design-systems-in-the-wild","placementSessionIds":["checkpoint-design-systems-in-the-wild"],"prerequisites":["design-design-lab"],"skillIds":["skill-lesson-case-study-whatsapp-messaging","skill-lesson-case-study-netflix-streaming","skill-lesson-case-study-github-collaboration","skill-lesson-case-study-uber-ridesharing"],"revision":"14be5058d630"},{"id":"coding-service-functions","courseId":"coding","order":1,"title":"Functions behind a service","description":"Translate capacity, routing, and caching decisions into working JavaScript.","sessionIds":["code-capacity","code-routing","code-cache","code-healthy-router"],"checkpointSessionId":"code-healthy-router","placementSessionIds":["code-capacity","code-routing","code-cache","code-healthy-router"],"prerequisites":[],"skillIds":["skill-code-capacity","skill-code-routing","skill-code-cache","skill-code-healthy-router"],"revision":"862580a2b8e9"},{"id":"coding-collections","courseId":"coding","order":2,"title":"Collections and batching","description":"Deduplicate, count, group, and batch data safely.","sessionIds":["code-unique-ids","code-count-events","code-group-jobs","code-batch-dedup","code-link-service"],"checkpointSessionId":"code-link-service","placementSessionIds":["code-unique-ids","code-count-events","code-group-jobs","code-batch-dedup","code-link-service"],"prerequisites":["coding-service-functions"],"skillIds":["skill-code-unique-ids","skill-code-count-events","skill-code-group-jobs","skill-code-batch-dedup","skill-code-link-service"],"revision":"efac908d6539"},{"id":"coding-api-boundaries","courseId":"coding","order":3,"title":"Reliable API boundaries","description":"Validate and normalize input, paginate results, and honor cache expiry.","sessionIds":["code-validate-limit","code-normalize-event","code-page-results","code-cache-ttl"],"checkpointSessionId":"code-cache-ttl","placementSessionIds":["code-validate-limit","code-normalize-event","code-page-results","code-cache-ttl"],"prerequisites":["coding-collections"],"skillIds":["skill-code-validate-limit","skill-code-normalize-event","skill-code-page-results","skill-code-cache-ttl"],"revision":"566d178851ab"},{"id":"coding-traffic-control","courseId":"coding","order":4,"title":"Control traffic","description":"Implement rate-limit models and combine them into a per-tenant admission policy.","sessionIds":["code-fixed-window","code-token-bucket","code-sliding-window","code-admit-batch"],"checkpointSessionId":"code-admit-batch","placementSessionIds":["code-fixed-window","code-token-bucket","code-sliding-window","code-admit-batch"],"prerequisites":["coding-api-boundaries"],"skillIds":["skill-code-fixed-window","skill-code-token-bucket","skill-code-sliding-window","skill-code-admit-batch"],"revision":"247ab27e9517"},{"id":"coding-safe-state","courseId":"coding","order":5,"title":"Make state changes safe","description":"Handle retries, stale writes, conflicting copies, and repeated events.","sessionIds":["code-idempotency","code-version-write","code-reconcile-records","code-apply-events"],"checkpointSessionId":"code-apply-events","placementSessionIds":["code-idempotency","code-version-write","code-reconcile-records","code-apply-events"],"prerequisites":["coding-traffic-control"],"skillIds":["skill-code-idempotency","skill-code-version-write","skill-code-reconcile-records","skill-code-apply-events"],"revision":"4e05b6d3b758"},{"id":"coding-job-processing","courseId":"coding","order":6,"title":"Build a resilient job worker","description":"Schedule work within retry budgets and capacity limits.","sessionIds":["code-backoff","code-ready-jobs","code-dead-letter","code-worker-plan"],"checkpointSessionId":"code-worker-plan","placementSessionIds":["code-backoff","code-ready-jobs","code-dead-letter","code-worker-plan"],"prerequisites":["coding-safe-state"],"skillIds":["skill-code-backoff","skill-code-ready-jobs","skill-code-dead-letter","skill-code-worker-plan"],"revision":"c0ec55965ea8"},{"id":"genai-llm-foundations","courseId":"genai","order":1,"title":"Understand language models","description":"Build a working mental model of tokens, transformers, and language-model behavior.","sessionIds":["lesson-llm-intro","lesson-transformers","lesson-llms","lesson-tokenization-fundamentals","lesson-bpe-algorithm","lesson-production-tokenization","checkpoint-genai-llm-foundations"],"checkpointSessionId":"checkpoint-genai-llm-foundations","placementSessionIds":["checkpoint-genai-llm-foundations"],"prerequisites":[],"skillIds":["skill-lesson-llm-intro","skill-lesson-transformers","skill-lesson-llms","skill-lesson-tokenization-fundamentals","skill-lesson-bpe-algorithm","skill-lesson-production-tokenization"],"revision":"f7a393ff9472"},{"id":"genai-prompt-and-tools","courseId":"genai","order":2,"title":"Prompts, conversations, and tools","description":"Turn model output into useful, structured application behavior.","sessionIds":["lesson-prompt-engineering","lesson-conversational-ai","lesson-function-calling","lesson-smart-text-completion","lesson-translation-systems","checkpoint-genai-prompt-and-tools"],"checkpointSessionId":"checkpoint-genai-prompt-and-tools","placementSessionIds":["checkpoint-genai-prompt-and-tools"],"prerequisites":["genai-llm-foundations"],"skillIds":["skill-lesson-prompt-engineering","skill-lesson-conversational-ai","skill-lesson-function-calling","skill-lesson-smart-text-completion","skill-lesson-translation-systems"],"revision":"d2b52a32c82c"},{"id":"genai-retrieval","courseId":"genai","order":3,"title":"Build with retrieval","description":"Connect models to useful knowledge and choose retrieval strategies.","sessionIds":["lesson-rag-systems","lesson-rag","lesson-advanced-rag","lesson-knowledge-graphs","lesson-rag-systems-foundation","lesson-rag-architecture-deep-dive","lesson-vector-database-implementation","checkpoint-genai-retrieval"],"checkpointSessionId":"checkpoint-genai-retrieval","placementSessionIds":["checkpoint-genai-retrieval"],"prerequisites":["genai-prompt-and-tools"],"skillIds":["skill-lesson-rag-systems","skill-lesson-rag","skill-lesson-advanced-rag","skill-lesson-knowledge-graphs","skill-lesson-rag-systems-foundation","skill-lesson-rag-architecture-deep-dive","skill-lesson-vector-database-implementation"],"revision":"8ea069918d71"},{"id":"genai-agents","courseId":"genai","order":4,"title":"Build agent systems","description":"Connect reasoning, tools, context, and application state.","sessionIds":["lesson-langchain-production","lesson-ai-agents","lesson-model-context-protocol","lesson-agentic-ai-systems","lesson-computer-use-agents","lesson-personalized-genai","checkpoint-genai-agents"],"checkpointSessionId":"checkpoint-genai-agents","placementSessionIds":["checkpoint-genai-agents"],"prerequisites":["genai-retrieval"],"skillIds":["skill-lesson-langchain-production","skill-lesson-ai-agents","skill-lesson-model-context-protocol","skill-lesson-agentic-ai-systems","skill-lesson-computer-use-agents","skill-lesson-personalized-genai"],"revision":"26aa1d006d77"},{"id":"genai-model-serving","courseId":"genai","order":5,"title":"Serve models efficiently","description":"Budget tokens, route requests, and scale inference.","sessionIds":["lesson-llm-serving","lesson-token-management","lesson-llm-inference-optimization","lesson-ai-gateway-patterns","lesson-model-serving-patterns","lesson-inference-time-scaling","lesson-production-transformer-architecture","checkpoint-genai-model-serving"],"checkpointSessionId":"checkpoint-genai-model-serving","placementSessionIds":["checkpoint-genai-model-serving"],"prerequisites":["genai-agents"],"skillIds":["skill-lesson-llm-serving","skill-lesson-token-management","skill-lesson-llm-inference-optimization","skill-lesson-ai-gateway-patterns","skill-lesson-model-serving-patterns","skill-lesson-inference-time-scaling","skill-lesson-production-transformer-architecture"],"revision":"5bed890badf6"},{"id":"genai-model-adaptation","courseId":"genai","order":6,"title":"Adapt models to a task","description":"Choose when and how to fine-tune a model with task-specific data.","sessionIds":["lesson-fine-tuning-practices","lesson-lora-fine-tuning","lesson-raft-fine-tuning","checkpoint-genai-model-adaptation"],"checkpointSessionId":"checkpoint-genai-model-adaptation","placementSessionIds":["checkpoint-genai-model-adaptation"],"prerequisites":["genai-model-serving"],"skillIds":["skill-lesson-fine-tuning-practices","skill-lesson-lora-fine-tuning","skill-lesson-raft-fine-tuning"],"revision":"3e164d089394"},{"id":"genai-vision-and-generation","courseId":"genai","order":7,"title":"Vision and generation","description":"Connect text and images, then understand generative visual models.","sessionIds":["lesson-clip-architecture","lesson-text-to-image","lesson-diffusion-models-production","lesson-text-to-image-system-design","lesson-video-generation","checkpoint-genai-vision-and-generation"],"checkpointSessionId":"checkpoint-genai-vision-and-generation","placementSessionIds":["checkpoint-genai-vision-and-generation"],"prerequisites":["genai-model-adaptation"],"skillIds":["skill-lesson-clip-architecture","skill-lesson-text-to-image","skill-lesson-diffusion-models-production","skill-lesson-text-to-image-system-design","skill-lesson-video-generation"],"revision":"c41b65d51b02"},{"id":"genai-multimodal","courseId":"genai","order":8,"title":"Build multimodal systems","description":"Reason about vision-language architectures, captioning, and mixtures of experts.","sessionIds":["lesson-image-captioning","lesson-multimodal-ai","lesson-advanced-image-captioning","lesson-blip3-xgen-mm","lesson-internvl3-architecture","lesson-multimodal-moe-systems","checkpoint-genai-multimodal"],"checkpointSessionId":"checkpoint-genai-multimodal","placementSessionIds":["checkpoint-genai-multimodal"],"prerequisites":["genai-vision-and-generation"],"skillIds":["skill-lesson-image-captioning","skill-lesson-multimodal-ai","skill-lesson-advanced-image-captioning","skill-lesson-blip3-xgen-mm","skill-lesson-internvl3-architecture","skill-lesson-multimodal-moe-systems"],"revision":"debb9808b1d8"},{"id":"genai-document-intelligence","courseId":"genai","order":9,"title":"Documents and data quality","description":"Extract usable information from documents and curate multimodal data.","sessionIds":["lesson-document-parsing-systems","lesson-production-document-extraction","lesson-laion-aesthetics","checkpoint-genai-document-intelligence"],"checkpointSessionId":"checkpoint-genai-document-intelligence","placementSessionIds":["checkpoint-genai-document-intelligence"],"prerequisites":["genai-multimodal"],"skillIds":["skill-lesson-document-parsing-systems","skill-lesson-production-document-extraction","skill-lesson-laion-aesthetics"],"revision":"b62cc48a705c"},{"id":"genai-evaluation","courseId":"genai","order":10,"title":"Measure model behavior","description":"Choose evaluation methods and build a repeatable evaluation pipeline.","sessionIds":["lesson-evaluation-benchmarks-comprehensive","lesson-llm-as-judge-evaluation","lesson-long-context-evaluation","lesson-agentic-ai-evaluation","lesson-production-evaluation-pipelines","lesson-evaluation-platforms","lesson-ai-evaluation-drift","checkpoint-genai-evaluation"],"checkpointSessionId":"checkpoint-genai-evaluation","placementSessionIds":["checkpoint-genai-evaluation"],"prerequisites":["genai-document-intelligence"],"skillIds":["skill-lesson-evaluation-benchmarks-comprehensive","skill-lesson-llm-as-judge-evaluation","skill-lesson-long-context-evaluation","skill-lesson-agentic-ai-evaluation","skill-lesson-production-evaluation-pipelines","skill-lesson-evaluation-platforms","skill-lesson-ai-evaluation-drift"],"revision":"27b949ce2482"},{"id":"genai-evaluation-domains","courseId":"genai","order":11,"title":"Test reasoning and knowledge","description":"Understand what different benchmarks measure and where they fall short.","sessionIds":["lesson-common-sense-reasoning-benchmarks","lesson-world-knowledge-benchmarks","lesson-mathematical-reasoning-benchmarks","lesson-code-generation-benchmarks","lesson-composite-benchmarks-mmlu","lesson-lmsys-arena-evaluation","checkpoint-genai-evaluation-domains"],"checkpointSessionId":"checkpoint-genai-evaluation-domains","placementSessionIds":["checkpoint-genai-evaluation-domains"],"prerequisites":["genai-evaluation"],"skillIds":["skill-lesson-common-sense-reasoning-benchmarks","skill-lesson-world-knowledge-benchmarks","skill-lesson-mathematical-reasoning-benchmarks","skill-lesson-code-generation-benchmarks","skill-lesson-composite-benchmarks-mmlu","skill-lesson-lmsys-arena-evaluation"],"revision":"800d113edc7b"},{"id":"genai-safety","courseId":"genai","order":12,"title":"Safety and robustness","description":"Evaluate harmful behavior, adversarial inputs, bias, and truthfulness.","sessionIds":["lesson-ai-safety","lesson-safety-evaluation","lesson-adversarial-testing","lesson-safety-evaluation-advanced","lesson-toxigen-hatecheck-evaluation","lesson-social-bias-measurement","lesson-truthfulqa-evaluation","lesson-adversarial-robustness-evaluation","checkpoint-genai-safety"],"checkpointSessionId":"checkpoint-genai-safety","placementSessionIds":["checkpoint-genai-safety"],"prerequisites":["genai-evaluation-domains"],"skillIds":["skill-lesson-ai-safety","skill-lesson-safety-evaluation","skill-lesson-adversarial-testing","skill-lesson-safety-evaluation-advanced","skill-lesson-toxigen-hatecheck-evaluation","skill-lesson-social-bias-measurement","skill-lesson-truthfulqa-evaluation","skill-lesson-adversarial-robustness-evaluation"],"revision":"d6431f4ea6df"},{"id":"genai-ai-operations","courseId":"genai","order":13,"title":"Operate AI products","description":"Monitor deployed systems, defend agents, and put governance into practice.","sessionIds":["lesson-genai-monitoring","lesson-production-deployment","lesson-agentic-ai-security","lesson-ai-governance-regulation","checkpoint-genai-ai-operations"],"checkpointSessionId":"checkpoint-genai-ai-operations","placementSessionIds":["checkpoint-genai-ai-operations"],"prerequisites":["genai-safety"],"skillIds":["skill-lesson-genai-monitoring","skill-lesson-production-deployment","skill-lesson-agentic-ai-security","skill-lesson-ai-governance-regulation"],"revision":"8196fe33843e"},{"id":"genai-genai-design","courseId":"genai","order":14,"title":"Design AI applications","description":"Use a repeatable process to reason about a complete generative AI system.","sessionIds":["lesson-genai-system-design-process","lesson-genai-interview-framework","lesson-gmail-smart-compose-architecture","checkpoint-genai-genai-design"],"checkpointSessionId":"checkpoint-genai-genai-design","placementSessionIds":["checkpoint-genai-genai-design"],"prerequisites":["genai-ai-operations"],"skillIds":["skill-lesson-genai-system-design-process","skill-lesson-genai-interview-framework","skill-lesson-gmail-smart-compose-architecture"],"revision":"eb264c746a7f"},{"id":"ml-ml-foundations","courseId":"ml","order":1,"title":"Frame the learning problem","description":"Connect the business problem to a model, objective, and evaluation plan.","sessionIds":["lesson-ml-fundamentals","lesson-discriminative-vs-generative","lesson-ml-problem-framing","lesson-ml-systems-design","lesson-model-evaluation","checkpoint-ml-ml-foundations"],"checkpointSessionId":"checkpoint-ml-ml-foundations","placementSessionIds":["checkpoint-ml-ml-foundations"],"prerequisites":[],"skillIds":["skill-lesson-ml-fundamentals","skill-lesson-discriminative-vs-generative","skill-lesson-ml-problem-framing","skill-lesson-ml-systems-design","skill-lesson-model-evaluation"],"revision":"846953eba3b5"},{"id":"ml-data-and-features","courseId":"ml","order":2,"title":"Build the data foundation","description":"Design pipelines, manage training data, and build useful features.","sessionIds":["lesson-data-pipeline-design","lesson-data-pipelines","lesson-training-data-management","lesson-feature-engineering","lesson-ml-datasets-deep-dive","lesson-data-preparation","lesson-pandas-ml","checkpoint-ml-data-and-features"],"checkpointSessionId":"checkpoint-ml-data-and-features","placementSessionIds":["checkpoint-ml-data-and-features"],"prerequisites":["ml-ml-foundations"],"skillIds":["skill-lesson-data-pipeline-design","skill-lesson-data-pipelines","skill-lesson-training-data-management","skill-lesson-feature-engineering","skill-lesson-ml-datasets-deep-dive","skill-lesson-data-preparation","skill-lesson-pandas-ml"],"revision":"2b0c7b3f4005"},{"id":"ml-data-quality","courseId":"ml","order":3,"title":"Curate training data","description":"Move from web-scale inputs to filtered, useful training examples.","sessionIds":["lesson-pretraining-data-sources","lesson-data-quality-filtering","lesson-demonstration-data","lesson-document-parsing","lesson-layout-parser","lesson-dedoc-systems","checkpoint-ml-data-quality"],"checkpointSessionId":"checkpoint-ml-data-quality","placementSessionIds":["checkpoint-ml-data-quality"],"prerequisites":["ml-data-and-features"],"skillIds":["skill-lesson-pretraining-data-sources","skill-lesson-data-quality-filtering","skill-lesson-demonstration-data","skill-lesson-document-parsing","skill-lesson-layout-parser","skill-lesson-dedoc-systems"],"revision":"3139c560bb02"},{"id":"ml-training","courseId":"ml","order":4,"title":"Train and explain models","description":"Understand training, explain predictions, and learn the foundations of reinforcement learning.","sessionIds":["lesson-model-training","lesson-shap-lime-explainability","lesson-llm-fundamentals","lesson-policy-gradient-theorem","lesson-rlhf","checkpoint-ml-training"],"checkpointSessionId":"checkpoint-ml-training","placementSessionIds":["checkpoint-ml-training"],"prerequisites":["ml-data-quality"],"skillIds":["skill-lesson-model-training","skill-lesson-shap-lime-explainability","skill-lesson-llm-fundamentals","skill-lesson-policy-gradient-theorem","skill-lesson-rlhf"],"revision":"f620efe21254"},{"id":"ml-ml-evaluation","courseId":"ml","order":5,"title":"Evaluate beyond one score","description":"Inspect reasoning, knowledge, and behavior across tasks.","sessionIds":["lesson-reasoning-evaluation","lesson-knowledge-evaluation","lesson-composite-benchmarks","lesson-ab-testing","checkpoint-ml-ml-evaluation"],"checkpointSessionId":"checkpoint-ml-ml-evaluation","placementSessionIds":["checkpoint-ml-ml-evaluation"],"prerequisites":["ml-training"],"skillIds":["skill-lesson-reasoning-evaluation","skill-lesson-knowledge-evaluation","skill-lesson-composite-benchmarks","skill-lesson-ab-testing"],"revision":"784ebc76816e"},{"id":"ml-efficient-models","courseId":"ml","order":6,"title":"Make models efficient","description":"Trade compute, memory, and accuracy with deliberate optimization.","sessionIds":["lesson-model-serving","lesson-model-quantization","lesson-knowledge-distillation","lesson-model-compression-techniques","lesson-flashattention-memory-optimization","checkpoint-ml-efficient-models"],"checkpointSessionId":"checkpoint-ml-efficient-models","placementSessionIds":["checkpoint-ml-efficient-models"],"prerequisites":["ml-ml-evaluation"],"skillIds":["skill-lesson-model-serving","skill-lesson-model-quantization","skill-lesson-knowledge-distillation","skill-lesson-model-compression-techniques","skill-lesson-flashattention-memory-optimization"],"revision":"ceab962e9cae"},{"id":"ml-ml-operations","courseId":"ml","order":7,"title":"Operate a changing model","description":"Detect drift, collect human feedback, and adapt models over time.","sessionIds":["lesson-data-distribution-shifts","lesson-mlops-monitoring","lesson-continual-learning","lesson-human-in-the-loop-ml","lesson-edge-ml-deployment","checkpoint-ml-ml-operations"],"checkpointSessionId":"checkpoint-ml-ml-operations","placementSessionIds":["checkpoint-ml-ml-operations"],"prerequisites":["ml-efficient-models"],"skillIds":["skill-lesson-data-distribution-shifts","skill-lesson-mlops-monitoring","skill-lesson-continual-learning","skill-lesson-human-in-the-loop-ml","skill-lesson-edge-ml-deployment"],"revision":"1cd2a87aceb9"},{"id":"ml-distributed-ml","courseId":"ml","order":8,"title":"Scale training and inference","description":"Coordinate compute, specialized experts, and low-latency model serving.","sessionIds":["lesson-distributed-training-advanced","lesson-mixture-of-experts","lesson-real-time-ml-inference","lesson-unified-ai-platform-architecture","lesson-serverless-mlops","checkpoint-ml-distributed-ml"],"checkpointSessionId":"checkpoint-ml-distributed-ml","placementSessionIds":["checkpoint-ml-distributed-ml"],"prerequisites":["ml-ml-operations"],"skillIds":["skill-lesson-distributed-training-advanced","skill-lesson-mixture-of-experts","skill-lesson-real-time-ml-inference","skill-lesson-unified-ai-platform-architecture","skill-lesson-serverless-mlops"],"revision":"75839e312412"},{"id":"ml-perception-and-language","courseId":"ml","order":9,"title":"Perception, language, and search","description":"Design the pipelines behind vision, language, recommendations, and search.","sessionIds":["lesson-computer-vision-systems","lesson-nlp-systems-architecture","lesson-recommender-systems-advanced","lesson-advanced-search-systems","lesson-multi-modal-ai-systems","checkpoint-ml-perception-and-language"],"checkpointSessionId":"checkpoint-ml-perception-and-language","placementSessionIds":["checkpoint-ml-perception-and-language"],"prerequisites":["ml-distributed-ml"],"skillIds":["skill-lesson-computer-vision-systems","skill-lesson-nlp-systems-architecture","skill-lesson-recommender-systems-advanced","skill-lesson-advanced-search-systems","skill-lesson-multi-modal-ai-systems"],"revision":"a421420bcceb"},{"id":"ml-ml-applications","courseId":"ml","order":10,"title":"ML in the real world","description":"Adapt architecture and evaluation to domain constraints.","sessionIds":["lesson-healthcare-ai","lesson-financial-ml","lesson-autonomous-systems","lesson-scientific-ml","lesson-real-time-analytics-systems","lesson-ai-safety-guardrails-systems","checkpoint-ml-ml-applications"],"checkpointSessionId":"checkpoint-ml-ml-applications","placementSessionIds":["checkpoint-ml-ml-applications"],"prerequisites":["ml-perception-and-language"],"skillIds":["skill-lesson-healthcare-ai","skill-lesson-financial-ml","skill-lesson-autonomous-systems","skill-lesson-scientific-ml","skill-lesson-real-time-analytics-systems","skill-lesson-ai-safety-guardrails-systems"],"revision":"443f0758e08d"},{"id":"ml-ml-frontiers","courseId":"ml","order":11,"title":"Explore advanced architectures","description":"Compare new model families, learning strategies, and embodied systems.","sessionIds":["lesson-advanced-ai-agents","lesson-advanced-reasoning","lesson-neural-architecture-search","lesson-federated-learning","lesson-world-models","lesson-robotics-agents","lesson-neuromorphic-computing","lesson-quantum-ml","checkpoint-ml-ml-frontiers"],"checkpointSessionId":"checkpoint-ml-ml-frontiers","placementSessionIds":["checkpoint-ml-ml-frontiers"],"prerequisites":["ml-ml-applications"],"skillIds":["skill-lesson-advanced-ai-agents","skill-lesson-advanced-reasoning","skill-lesson-neural-architecture-search","skill-lesson-federated-learning","skill-lesson-world-models","skill-lesson-robotics-agents","skill-lesson-neuromorphic-computing","skill-lesson-quantum-ml"],"revision":"88a2ad528828"},{"id":"python-hello","courseId":"python","order":1,"title":"Hello, Python","description":"Print values, name them with variables, calculate with numbers, and build strings.","sessionIds":["python-hello-1","python-hello-2","python-hello-3","python-hello-4","python-hello-5"],"checkpointSessionId":"python-hello-5","placementSessionIds":["python-hello-5"],"prerequisites":[],"skillIds":["skill-python-print-values","skill-python-assign-variables","skill-python-use-number-types","skill-python-build-strings"],"revision":"py1"},{"id":"python-decisions","courseId":"python","order":2,"title":"Making decisions","description":"Compare values, branch with if/elif/else, combine conditions, and judge what counts as true.","sessionIds":["python-decisions-1","python-decisions-2","python-decisions-3","python-decisions-4","python-decisions-5"],"checkpointSessionId":"python-decisions-5","placementSessionIds":["python-decisions-5"],"prerequisites":["python-hello"],"skillIds":["skill-python-compare-values","skill-python-branch-with-if","skill-python-combine-conditions","skill-python-judge-truthiness"],"revision":"py1"},{"id":"python-repeating","courseId":"python","order":3,"title":"Repeating","description":"Run a block once per item with for, count with range, repeat with while, and steer a loop with break and continue.","sessionIds":["python-repeating-1","python-repeating-2","python-repeating-3","python-repeating-4","python-repeating-5"],"checkpointSessionId":"python-repeating-5","placementSessionIds":["python-repeating-5"],"prerequisites":["python-decisions"],"skillIds":["skill-python-loop-with-for","skill-python-use-range","skill-python-loop-with-while","skill-python-control-loop-flow"],"revision":"py1"},{"id":"python-collections","courseId":"python","order":4,"title":"Collections","description":"Index and slice lists, change them in place, and tell a shared list from a copy.","sessionIds":["python-collections-1","python-collections-2","python-collections-3","python-collections-4","python-collections-5"],"checkpointSessionId":"python-collections-5","placementSessionIds":["python-collections-5"],"prerequisites":["python-repeating"],"skillIds":["skill-python-index-lists","skill-python-slice-lists","skill-python-mutate-lists","skill-python-alias-lists"],"revision":"py1"},{"id":"python-dicts","courseId":"python","order":5,"title":"Dictionaries and sets","description":"Look values up by key, change and loop over a dictionary, and use sets to keep values unique.","sessionIds":["python-dicts-1","python-dicts-2","python-dicts-3","python-dicts-4","python-dicts-5"],"checkpointSessionId":"python-dicts-5","placementSessionIds":["python-dicts-5"],"prerequisites":["python-collections"],"skillIds":["skill-python-read-dicts","skill-python-update-dicts","skill-python-loop-dicts","skill-python-use-sets"],"revision":"py1"},{"id":"python-functions","courseId":"python","order":6,"title":"Functions","description":"Define functions with def, pass arguments by position or name, return values, and keep names local.","sessionIds":["python-functions-1","python-functions-2","python-functions-3","python-functions-4","python-functions-5"],"checkpointSessionId":"python-functions-5","placementSessionIds":["python-functions-5"],"prerequisites":["python-dicts"],"skillIds":["skill-python-define-functions","skill-python-pass-arguments","skill-python-return-values","skill-python-scope-names"],"revision":"py1"},{"id":"python-strings","courseId":"python","order":7,"title":"Strings for real","description":"Slice text that never changes, split and join it, format it with f-strings, and search inside it.","sessionIds":["python-strings-1","python-strings-2","python-strings-3","python-strings-4","python-strings-5"],"checkpointSessionId":"python-strings-5","placementSessionIds":["python-strings-5"],"prerequisites":["python-functions"],"skillIds":["skill-python-slice-strings","skill-python-split-join-strings","skill-python-format-strings","skill-python-search-strings"],"revision":"py1"},{"id":"python-errors","courseId":"python","order":8,"title":"Errors","description":"Read a traceback, catch the exception you meant to catch, use else and finally, and raise on purpose.","sessionIds":["python-errors-1","python-errors-2","python-errors-3","python-errors-4","python-errors-5"],"checkpointSessionId":"python-errors-5","placementSessionIds":["python-errors-5"],"prerequisites":["python-strings"],"skillIds":["skill-python-read-tracebacks","skill-python-catch-exceptions","skill-python-use-else-finally","skill-python-raise-errors"],"revision":"py1"},{"id":"javascript-values","courseId":"javascript","order":1,"title":"Values and variables","description":"Declare variables, read types, convert between strings and numbers, and do arithmetic.","sessionIds":["javascript-values-1","javascript-values-2","javascript-values-3","javascript-values-4","javascript-values-5"],"checkpointSessionId":"javascript-values-5","placementSessionIds":["javascript-values-5"],"prerequisites":[],"skillIds":["skill-javascript-declare-variables","skill-javascript-identify-types","skill-javascript-convert-types","skill-javascript-use-operators"],"revision":"js1"},{"id":"javascript-functions","courseId":"javascript","order":2,"title":"Functions and scope","description":"Write functions and arrow functions, pass arguments, and reason about scope, closures and hoisting.","sessionIds":["javascript-functions-1","javascript-functions-2","javascript-functions-3","javascript-functions-4","javascript-functions-5"],"checkpointSessionId":"javascript-functions-5","placementSessionIds":["javascript-functions-5"],"prerequisites":["javascript-values"],"skillIds":["skill-javascript-define-functions","skill-javascript-pass-arguments","skill-javascript-scope-variables","skill-javascript-avoid-hoisting-traps"],"revision":"js1"},{"id":"javascript-arrays","courseId":"javascript","order":3,"title":"Arrays and iteration","description":"Transform, search, fold and sort arrays, and tell the methods that copy from the ones that mutate.","sessionIds":["javascript-arrays-1","javascript-arrays-2","javascript-arrays-3","javascript-arrays-4","javascript-arrays-5"],"checkpointSessionId":"javascript-arrays-5","placementSessionIds":["javascript-arrays-5"],"prerequisites":["javascript-functions"],"skillIds":["skill-javascript-transform-arrays","skill-javascript-search-arrays","skill-javascript-reduce-arrays","skill-javascript-sort-arrays"],"revision":"js1"},{"id":"javascript-objects","courseId":"javascript","order":4,"title":"Objects and JSON","description":"Read and write properties, destructure and spread, tell references from copies, and convert with JSON.","sessionIds":["javascript-objects-1","javascript-objects-2","javascript-objects-3","javascript-objects-4","javascript-objects-5"],"checkpointSessionId":"javascript-objects-5","placementSessionIds":["javascript-objects-5"],"prerequisites":["javascript-arrays"],"skillIds":["skill-javascript-access-properties","skill-javascript-destructure-values","skill-javascript-copy-references","skill-javascript-use-json"],"revision":"js1"},{"id":"javascript-control-flow","courseId":"javascript","order":5,"title":"Control flow and truthiness","description":"Compare values honestly, judge truthiness, choose defaults with ?? and ?., and branch with ternaries, switch and early returns.","sessionIds":["javascript-control-flow-1","javascript-control-flow-2","javascript-control-flow-3","javascript-control-flow-4","javascript-control-flow-5"],"checkpointSessionId":"javascript-control-flow-5","placementSessionIds":["javascript-control-flow-5"],"prerequisites":["javascript-objects"],"skillIds":["skill-javascript-compare-values","skill-javascript-judge-truthiness","skill-javascript-choose-defaults","skill-javascript-branch-flow"],"revision":"js1"},{"id":"javascript-strings","courseId":"javascript","order":6,"title":"Strings and text","description":"Build strings with template literals, cut them with slice, split and join, search them, and clean them with trim, case and replace.","sessionIds":["javascript-strings-1","javascript-strings-2","javascript-strings-3","javascript-strings-4","javascript-strings-5"],"checkpointSessionId":"javascript-strings-5","placementSessionIds":["javascript-strings-5"],"prerequisites":["javascript-control-flow"],"skillIds":["skill-javascript-build-strings","skill-javascript-cut-strings","skill-javascript-search-strings","skill-javascript-clean-strings"],"revision":"js1"},{"id":"javascript-async","courseId":"javascript","order":7,"title":"Asynchrony","description":"Work with callbacks and promises, chain with then, use async and await with try/catch, and predict the order the event loop runs things in.","sessionIds":["javascript-async-1","javascript-async-2","javascript-async-3","javascript-async-4","javascript-async-5"],"checkpointSessionId":"javascript-async-5","placementSessionIds":["javascript-async-5"],"prerequisites":["javascript-strings"],"skillIds":["skill-javascript-use-callbacks","skill-javascript-chain-promises","skill-javascript-await-promises","skill-javascript-order-event-loop"],"revision":"js1"},{"id":"javascript-modern","courseId":"javascript","order":8,"title":"Errors and modern syntax","description":"Throw and catch errors, destructure with defaults, spread and gather with rest, and write a class you can export from a module.","sessionIds":["javascript-modern-1","javascript-modern-2","javascript-modern-3","javascript-modern-4","javascript-modern-5"],"checkpointSessionId":"javascript-modern-5","placementSessionIds":["javascript-modern-5"],"prerequisites":["javascript-async"],"skillIds":["skill-javascript-throw-errors","skill-javascript-unpack-values","skill-javascript-spread-values","skill-javascript-write-classes"],"revision":"js1"},{"id":"dsa-big-o","courseId":"dsa","order":1,"title":"Big-O by feel","description":"Count what a loop really does on a small input, then say how the count grows when the input grows.","sessionIds":["dsa-big-o-1","dsa-big-o-2","dsa-big-o-3","dsa-big-o-4","dsa-big-o-5"],"checkpointSessionId":"dsa-big-o-5","placementSessionIds":["dsa-big-o-5"],"prerequisites":[],"skillIds":["skill-dsa-count-steps","skill-dsa-name-the-class","skill-dsa-compare-growth"],"revision":"dsa1"},{"id":"dsa-arrays","courseId":"dsa","order":2,"title":"Arrays and strings","description":"An index read is free, a scan costs n, and anything that moves the front of an array costs n too. Learn which end to use.","sessionIds":["dsa-arrays-1","dsa-arrays-2","dsa-arrays-3","dsa-arrays-4","dsa-arrays-5"],"checkpointSessionId":"dsa-arrays-5","placementSessionIds":["dsa-arrays-5"],"prerequisites":["dsa-big-o"],"skillIds":["skill-dsa-index-arrays","skill-dsa-walk-two-pointers","skill-dsa-slide-windows","skill-dsa-weigh-shift-cost"],"revision":"dsa1"},{"id":"dsa-hash-maps","courseId":"dsa","order":3,"title":"Hash maps and sets","description":"Trade memory for speed: a Map or a Set answers by key in one bucket visit, turning nested scans into single passes.","sessionIds":["dsa-hash-maps-1","dsa-hash-maps-2","dsa-hash-maps-3","dsa-hash-maps-4","dsa-hash-maps-5"],"checkpointSessionId":"dsa-hash-maps-5","placementSessionIds":["dsa-hash-maps-5"],"prerequisites":["dsa-arrays"],"skillIds":["skill-dsa-look-up-by-key","skill-dsa-count-with-maps","skill-dsa-track-seen","skill-dsa-judge-key-identity"],"revision":"dsa1"},{"id":"dsa-stacks-queues","courseId":"dsa","order":4,"title":"Stacks and queues","description":"Last in first out, or first in first out. Trace both on paper, build a bracket matcher, and learn which question each shape answers.","sessionIds":["dsa-stacks-queues-1","dsa-stacks-queues-2","dsa-stacks-queues-3","dsa-stacks-queues-4","dsa-stacks-queues-5"],"checkpointSessionId":"dsa-stacks-queues-5","placementSessionIds":["dsa-stacks-queues-5"],"prerequisites":["dsa-hash-maps"],"skillIds":["skill-dsa-push-and-pop","skill-dsa-match-brackets","skill-dsa-serve-in-order","skill-dsa-pick-the-shape"],"revision":"dsa1"},{"id":"dsa-linked-lists","courseId":"dsa","order":5,"title":"Linked lists","description":"Nodes joined by pointers: cheap at the front, a walk everywhere else. Trace the chain, rewire it, and reverse it in one pass.","sessionIds":["dsa-linked-lists-1","dsa-linked-lists-2","dsa-linked-lists-3","dsa-linked-lists-4","dsa-linked-lists-5"],"checkpointSessionId":"dsa-linked-lists-5","placementSessionIds":["dsa-linked-lists-5"],"prerequisites":["dsa-stacks-queues"],"skillIds":["skill-dsa-follow-next","skill-dsa-rewire-nodes","skill-dsa-reverse-a-list","skill-dsa-weigh-list-cost"],"revision":"dsa1"},{"id":"dsa-recursion","courseId":"dsa","order":6,"title":"Recursion","description":"A base case, a shrinking input, and a stack of frames underneath. Trace the calls, watch the depth, and cache what repeats.","sessionIds":["dsa-recursion-1","dsa-recursion-2","dsa-recursion-3","dsa-recursion-4","dsa-recursion-5"],"checkpointSessionId":"dsa-recursion-5","placementSessionIds":["dsa-recursion-5"],"prerequisites":["dsa-linked-lists"],"skillIds":["skill-dsa-find-the-base-case","skill-dsa-trace-the-call-stack","skill-dsa-swap-loop-and-recursion","skill-dsa-memoise-repeats"],"revision":"dsa1"},{"id":"dsa-trees","courseId":"dsa","order":7,"title":"Trees","description":"Nodes with two children, measured in height. Walk one three ways, search a sorted one, and see what balance is worth.","sessionIds":["dsa-trees-1","dsa-trees-2","dsa-trees-3","dsa-trees-4","dsa-trees-5"],"checkpointSessionId":"dsa-trees-5","placementSessionIds":["dsa-trees-5"],"prerequisites":["dsa-recursion"],"skillIds":["skill-dsa-read-tree-shape","skill-dsa-traverse-a-tree","skill-dsa-search-a-bst","skill-dsa-weigh-tree-balance"],"revision":"dsa1"},{"id":"dsa-graphs","courseId":"dsa","order":8,"title":"Graphs","description":"Nodes, neighbours and a visited set. Trace both searches on a real graph, and count the hops breadth-first finds.","sessionIds":["dsa-graphs-1","dsa-graphs-2","dsa-graphs-3","dsa-graphs-4","dsa-graphs-5"],"checkpointSessionId":"dsa-graphs-5","placementSessionIds":["dsa-graphs-5"],"prerequisites":["dsa-trees"],"skillIds":["skill-dsa-read-adjacency","skill-dsa-order-bfs-dfs","skill-dsa-guard-with-visited","skill-dsa-find-shortest-hops"],"revision":"dsa1"},{"id":"sql-tables","courseId":"sql","order":1,"title":"Tables and rows","description":"Read a schema, add rows with INSERT, tell a column type from a value, and say what NULL really means.","sessionIds":["sql-tables-1","sql-tables-2","sql-tables-3","sql-tables-4","sql-tables-5"],"checkpointSessionId":"sql-tables-5","placementSessionIds":["sql-tables-5"],"prerequisites":[],"skillIds":["skill-sql-read-a-table","skill-sql-insert-rows","skill-sql-name-column-types","skill-sql-use-primary-keys"],"revision":"sql1"},{"id":"sql-select","courseId":"sql","order":2,"title":"SELECT and WHERE","description":"Pick the columns you want, keep the rows you mean, get NULL right, then sort, cut and de-duplicate the answer.","sessionIds":["sql-select-1","sql-select-2","sql-select-3","sql-select-4","sql-select-5"],"checkpointSessionId":"sql-select-5","placementSessionIds":["sql-select-5"],"prerequisites":["sql-tables"],"skillIds":["skill-sql-select-columns","skill-sql-filter-with-where","skill-sql-compare-with-null","skill-sql-sort-and-limit"],"revision":"sql1"},{"id":"sql-joins","courseId":"sql","order":3,"title":"JOINs","description":"Follow a foreign key, pair rows with INNER JOIN, keep the unmatched ones with LEFT JOIN, and count what a one-to-many join returns.","sessionIds":["sql-joins-1","sql-joins-2","sql-joins-3","sql-joins-4","sql-joins-5"],"checkpointSessionId":"sql-joins-5","placementSessionIds":["sql-joins-5"],"prerequisites":["sql-select"],"skillIds":["skill-sql-link-with-foreign-keys","skill-sql-join-matching-rows","skill-sql-keep-unmatched-rows","skill-sql-count-join-rows"],"revision":"sql1"},{"id":"sql-aggregates","courseId":"sql","order":4,"title":"GROUP BY and aggregates","description":"Collapse rows with COUNT, SUM, AVG, MIN and MAX, watch what NULL does to a count, split rows into groups, and filter those groups with HAVING.","sessionIds":["sql-aggregates-1","sql-aggregates-2","sql-aggregates-3","sql-aggregates-4","sql-aggregates-5"],"checkpointSessionId":"sql-aggregates-5","placementSessionIds":["sql-aggregates-5"],"prerequisites":["sql-joins"],"skillIds":["skill-sql-summarize-with-aggregates","skill-sql-count-with-nulls","skill-sql-group-rows","skill-sql-filter-groups-with-having"],"revision":"sql1"},{"id":"sql-indexes","courseId":"sql","order":5,"title":"Indexes and query plans","description":"See why a sorted copy of a column turns a scan into a jump, what that costs on every write, when the planner ignores an index, and how to read the plan it chose.","sessionIds":["sql-indexes-1","sql-indexes-2","sql-indexes-3","sql-indexes-4","sql-indexes-5"],"checkpointSessionId":"sql-indexes-5","placementSessionIds":["sql-indexes-5"],"prerequisites":["sql-aggregates"],"skillIds":["skill-sql-explain-an-index","skill-sql-weigh-index-cost","skill-sql-spot-unusable-indexes","skill-sql-read-a-query-plan"],"revision":"sql1"},{"id":"sql-transactions","courseId":"sql","order":6,"title":"Transactions and schema design","description":"Make several writes one all-or-nothing unit with BEGIN and COMMIT, see what two connections can do to each other's reads, and put every fact in exactly one place.","sessionIds":["sql-transactions-1","sql-transactions-2","sql-transactions-3","sql-transactions-4","sql-transactions-5"],"checkpointSessionId":"sql-transactions-5","placementSessionIds":["sql-transactions-5"],"prerequisites":["sql-indexes"],"skillIds":["skill-sql-explain-acid","skill-sql-run-a-transaction","skill-sql-spot-isolation-bugs","skill-sql-normalize-a-schema"],"revision":"sql1"},{"id":"typescript-types","courseId":"typescript","order":1,"title":"Types and inference","description":"Annotate primitives, read what the compiler infers, tell any from unknown, and keep literal types narrow.","sessionIds":["typescript-types-1","typescript-types-2","typescript-types-3","typescript-types-4","typescript-types-5"],"checkpointSessionId":"typescript-types-5","placementSessionIds":["typescript-types-5"],"prerequisites":[],"skillIds":["skill-typescript-annotate-values","skill-typescript-read-inference","skill-typescript-handle-unknown","skill-typescript-use-literal-types"],"revision":"ts1"},{"id":"typescript-objects","courseId":"typescript","order":2,"title":"Objects and interfaces","description":"Name object shapes with interfaces and type aliases, mark properties optional or readonly, open a type up with an index signature, and see why shapes match by structure.","sessionIds":["typescript-objects-1","typescript-objects-2","typescript-objects-3","typescript-objects-4","typescript-objects-5"],"checkpointSessionId":"typescript-objects-5","placementSessionIds":["typescript-objects-5"],"prerequisites":["typescript-types"],"skillIds":["skill-typescript-declare-interfaces","skill-typescript-mark-optional-readonly","skill-typescript-index-objects","skill-typescript-check-shapes"],"revision":"ts1"},{"id":"typescript-unions","courseId":"typescript","order":3,"title":"Unions and narrowing","description":"Say that a value is one of several types, prove which one it is with typeof, in and truthiness, tag the branches, and let never tell you when a case is missing.","sessionIds":["typescript-unions-1","typescript-unions-2","typescript-unions-3","typescript-unions-4","typescript-unions-5"],"checkpointSessionId":"typescript-unions-5","placementSessionIds":["typescript-unions-5"],"prerequisites":["typescript-objects"],"skillIds":["skill-typescript-build-unions","skill-typescript-narrow-types","skill-typescript-tag-unions","skill-typescript-exhaust-cases"],"revision":"ts1"},{"id":"typescript-functions","courseId":"typescript","order":4,"title":"Typing functions","description":"Annotate parameters and returns, make parameters optional or defaulted, tell void from undefined, and describe the functions you pass to other functions.","sessionIds":["typescript-functions-1","typescript-functions-2","typescript-functions-3","typescript-functions-4","typescript-functions-5"],"checkpointSessionId":"typescript-functions-5","placementSessionIds":["typescript-functions-5"],"prerequisites":["typescript-unions"],"skillIds":["skill-typescript-type-signatures","skill-typescript-default-params","skill-typescript-return-void","skill-typescript-type-callbacks"],"revision":"ts1"},{"id":"typescript-generics","courseId":"typescript","order":5,"title":"Generics","description":"Write a function that keeps the type it was given, constrain a type parameter with extends, declare generic interfaces and aliases, and recognise a generic that earns nothing.","sessionIds":["typescript-generics-1","typescript-generics-2","typescript-generics-3","typescript-generics-4","typescript-generics-5"],"checkpointSessionId":"typescript-generics-5","placementSessionIds":["typescript-generics-5"],"prerequisites":["typescript-functions"],"skillIds":["skill-typescript-write-generics","skill-typescript-constrain-generics","skill-typescript-declare-generic-types","skill-typescript-judge-generics"],"revision":"ts1"},{"id":"typescript-practical","courseId":"typescript","order":6,"title":"Typing real code","description":"Build new types out of the ones you have, type the data that arrives from outside, keep as assertions rare and honest, and handle null and undefined under strict.","sessionIds":["typescript-practical-1","typescript-practical-2","typescript-practical-3","typescript-practical-4","typescript-practical-5"],"checkpointSessionId":"typescript-practical-5","placementSessionIds":["typescript-practical-5"],"prerequisites":["typescript-generics"],"skillIds":["skill-typescript-apply-utility-types","skill-typescript-type-api-data","skill-typescript-limit-assertions","skill-typescript-handle-null"],"revision":"ts1"},{"id":"web-http","courseId":"web","order":1,"title":"HTTP by hand","description":"Read a request and a response line by line, say what each method promises, tell a status family at a glance, and know why GET must never change anything.","sessionIds":["web-http-1","web-http-2","web-http-3","web-http-4","web-http-5"],"checkpointSessionId":"web-http-5","placementSessionIds":["web-http-5"],"prerequisites":[],"skillIds":["skill-web-read-a-request","skill-web-choose-a-method","skill-web-read-status-codes","skill-web-judge-safe-and-idempotent"],"revision":"web1"},{"id":"web-rest","courseId":"web","order":2,"title":"Designing an API","description":"Turn a domain into resources and URLs, decide whether a value belongs in the path, the query or the body, answer writes with the right status, and page, version and fail in one consistent shape.","sessionIds":["web-rest-1","web-rest-2","web-rest-3","web-rest-4","web-rest-5"],"checkpointSessionId":"web-rest-5","placementSessionIds":["web-rest-5"],"prerequisites":["web-http"],"skillIds":["skill-web-model-resources","skill-web-place-parameters","skill-web-answer-with-status","skill-web-page-and-version"],"revision":"web1"},{"id":"web-json","courseId":"web","order":3,"title":"JSON and payloads","description":"Read the shape of a payload, reach a value inside a nested one, tell null from missing from empty, and know which status a body earns when it will not parse.","sessionIds":["web-json-1","web-json-2","web-json-3","web-json-4","web-json-5"],"checkpointSessionId":"web-json-5","placementSessionIds":["web-json-5"],"prerequisites":["web-rest"],"skillIds":["skill-web-read-json-shapes","skill-web-navigate-nested-json","skill-web-tell-null-from-missing","skill-web-handle-bad-payloads"],"revision":"web1"},{"id":"web-auth","courseId":"web","order":4,"title":"Identity on the web","description":"Keep a user signed in with a cookie session, send a bearer token by hand, read what a JWT does and does not promise, survive expiry with a refresh, and keep every secret off the client.","sessionIds":["web-auth-1","web-auth-2","web-auth-3","web-auth-4","web-auth-5"],"checkpointSessionId":"web-auth-5","placementSessionIds":["web-auth-5"],"prerequisites":["web-json"],"skillIds":["skill-web-run-a-session","skill-web-read-a-jwt","skill-web-handle-expiry","skill-web-protect-secrets"],"revision":"web1"},{"id":"web-browser","courseId":"web","order":5,"title":"The browser side","description":"Follow the requests and redirects a single page load makes, decide when two URLs share an origin, work out when the browser preflights, and read the headers that decide what it caches.","sessionIds":["web-browser-1","web-browser-2","web-browser-3","web-browser-4","web-browser-5"],"checkpointSessionId":"web-browser-5","placementSessionIds":["web-browser-5"],"prerequisites":["web-auth"],"skillIds":["skill-web-trace-a-page-load","skill-web-apply-same-origin","skill-web-run-a-preflight","skill-web-read-cache-headers"],"revision":"web1"},{"id":"web-reliability","courseId":"web","order":6,"title":"When it goes wrong","description":"Give every call a deadline, retry only what is safe and only with backoff, make a repeated write harmless with an idempotency key, and read a 429 or an error body for what to do next.","sessionIds":["web-reliability-1","web-reliability-2","web-reliability-3","web-reliability-4","web-reliability-5"],"checkpointSessionId":"web-reliability-5","placementSessionIds":["web-reliability-5"],"prerequisites":["web-browser"],"skillIds":["skill-web-handle-timeouts","skill-web-retry-with-backoff","skill-web-use-idempotency-keys","skill-web-respect-rate-limits"],"revision":"web1"},{"id":"git-basics","courseId":"git","order":1,"title":"Commits and history","description":"Move a change through the working tree, the staging area and the repository, read status and diff, say what a commit really holds, and write a message the next person can use.","sessionIds":["git-basics-1","git-basics-2","git-basics-3","git-basics-4","git-basics-5"],"checkpointSessionId":"git-basics-5","placementSessionIds":["git-basics-5"],"prerequisites":[],"skillIds":["skill-git-stage-changes","skill-git-read-status","skill-git-record-commits","skill-git-write-messages"],"revision":"git1"},{"id":"git-branches","courseId":"git","order":2,"title":"Branching","description":"See a branch for what it is — a moving pointer at one commit — create and delete them, follow HEAD, and tell a history that fast-forwards from one that has diverged.","sessionIds":["git-branches-1","git-branches-2","git-branches-3","git-branches-4","git-branches-5"],"checkpointSessionId":"git-branches-5","placementSessionIds":["git-branches-5"],"prerequisites":["git-basics"],"skillIds":["skill-git-create-branches","skill-git-switch-branches","skill-git-explain-head","skill-git-compare-histories"],"revision":"git1"},{"id":"git-merging","courseId":"git","order":3,"title":"Merging and rebasing","description":"Join two lines of work: fast-forward and merge commits, conflict markers and how to read them, what a rebase rewrites, and which of the two to reach for.","sessionIds":["git-merging-1","git-merging-2","git-merging-3","git-merging-4","git-merging-5"],"checkpointSessionId":"git-merging-5","placementSessionIds":["git-merging-5"],"prerequisites":["git-branches"],"skillIds":["skill-git-merge-branches","skill-git-read-conflicts","skill-git-rebase-commits","skill-git-choose-integration"],"revision":"git1"},{"id":"git-remotes","courseId":"git","order":4,"title":"Working with a remote","description":"Clone a repository, keep origin/main straight from main, read ahead and behind, understand pull as fetch plus merge, and know what a force push costs the rest of the team.","sessionIds":["git-remotes-1","git-remotes-2","git-remotes-3","git-remotes-4","git-remotes-5"],"checkpointSessionId":"git-remotes-5","placementSessionIds":["git-remotes-5"],"prerequisites":["git-merging"],"skillIds":["skill-git-clone-and-fetch","skill-git-track-branches","skill-git-pull-and-push","skill-git-weigh-force-push"],"revision":"git1"},{"id":"git-recovery","courseId":"git","order":5,"title":"Undoing things","description":"Throw away an edit with restore, choose revert or reset and know what each mode keeps, amend and stash, and use the reflog to find work you thought you had lost.","sessionIds":["git-recovery-1","git-recovery-2","git-recovery-3","git-recovery-4","git-recovery-5"],"checkpointSessionId":"git-recovery-5","placementSessionIds":["git-recovery-5"],"prerequisites":["git-remotes"],"skillIds":["skill-git-restore-files","skill-git-choose-undo","skill-git-amend-and-stash","skill-git-use-reflog"],"revision":"git1"},{"id":"devops-containers","courseId":"devops","order":1,"title":"Containers","description":"Tell an image from a container and both from a virtual machine, read a Dockerfile line by line, order the layers so the cache survives, and publish a port without losing your data.","sessionIds":["devops-containers-1","devops-containers-2","devops-containers-3","devops-containers-4","devops-containers-5"],"checkpointSessionId":"devops-containers-5","placementSessionIds":["devops-containers-5"],"prerequisites":[],"skillIds":["skill-devops-tell-image-from-container","skill-devops-read-a-dockerfile","skill-devops-order-layers-for-cache","skill-devops-run-a-container"],"revision":"ops1"},{"id":"devops-pipelines","courseId":"devops","order":2,"title":"CI/CD","description":"Say what a pipeline runs and when it runs it, put stages and gates in an order that means something, build an artifact once and promote it, and keep a secret out of the log.","sessionIds":["devops-pipelines-1","devops-pipelines-2","devops-pipelines-3","devops-pipelines-4","devops-pipelines-5"],"checkpointSessionId":"devops-pipelines-5","placementSessionIds":["devops-pipelines-5"],"prerequisites":["devops-containers"],"skillIds":["skill-devops-trace-a-pipeline","skill-devops-order-stages-and-gates","skill-devops-build-once-and-promote","skill-devops-handle-ci-secrets"],"revision":"ops1"},{"id":"devops-config","courseId":"devops","order":3,"title":"Configuration and secrets","description":"Read configuration from the environment, keep one build for every environment, know which values must never reach the image or the repository, and rotate the ones that leak.","sessionIds":["devops-config-1","devops-config-2","devops-config-3","devops-config-4","devops-config-5"],"checkpointSessionId":"devops-config-5","placementSessionIds":["devops-config-5"],"prerequisites":["devops-pipelines"],"skillIds":["skill-devops-read-env-vars","skill-devops-configure-per-environment","skill-devops-apply-twelve-factor","skill-devops-rotate-a-secret"],"revision":"ops1"},{"id":"devops-deploy","courseId":"devops","order":4,"title":"Deploying safely","description":"Choose between rolling, blue/green and canary knowing what each costs, prove an instance is ready before it takes traffic, keep rollback a first-class plan, and sequence a migration that outlives the deploy.","sessionIds":["devops-deploy-1","devops-deploy-2","devops-deploy-3","devops-deploy-4","devops-deploy-5"],"checkpointSessionId":"devops-deploy-5","placementSessionIds":["devops-deploy-5"],"prerequisites":["devops-config"],"skillIds":["skill-devops-choose-a-rollout","skill-devops-wire-health-checks","skill-devops-plan-a-rollback","skill-devops-sequence-migrations"],"revision":"ops1"},{"id":"devops-observability","courseId":"devops","order":5,"title":"Knowing what happened","description":"Pick the signal that answers the question you actually have, keep a label from exploding, read the tail instead of the mean, and alert on what a user feels rather than on a cause you guessed.","sessionIds":["devops-observability-1","devops-observability-2","devops-observability-3","devops-observability-4","devops-observability-5"],"checkpointSessionId":"devops-observability-5","placementSessionIds":["devops-observability-5"],"prerequisites":["devops-deploy"],"skillIds":["skill-devops-choose-a-signal","skill-devops-control-cardinality","skill-devops-read-percentiles","skill-devops-alert-on-symptoms"],"revision":"ops1"},{"id":"devops-cloud","courseId":"devops","order":6,"title":"Cloud building blocks","description":"Choose between a virtual machine, a container and a function, decide what you are willing to run yourself, spread across zones for the failures that actually happen, and read what really drives a bill.","sessionIds":["devops-cloud-1","devops-cloud-2","devops-cloud-3","devops-cloud-4","devops-cloud-5"],"checkpointSessionId":"devops-cloud-5","placementSessionIds":["devops-cloud-5"],"prerequisites":["devops-observability"],"skillIds":["skill-devops-choose-compute","skill-devops-choose-managed-or-self-run","skill-devops-place-across-zones","skill-devops-read-a-cloud-bill"],"revision":"ops1"},{"id":"security-injection","courseId":"security","order":1,"title":"Untrusted input","description":"Follow a value from a form into a query, a shell command and a file path, and learn the one rule underneath all three: data must never become code.","sessionIds":["security-injection-1","security-injection-2","security-injection-3","security-injection-4","security-injection-5"],"checkpointSessionId":"security-injection-5","placementSessionIds":["security-injection-5"],"prerequisites":[],"skillIds":["skill-security-spot-untrusted-input","skill-security-parameterise-queries","skill-security-avoid-command-injection","skill-security-block-path-traversal"],"revision":"sec1"},{"id":"security-authn","courseId":"security","order":2,"title":"Authentication","description":"Store a password so that a stolen database is survivable, salt and slow the hash, issue a session token that cannot be guessed, and keep a login standing under credential stuffing.","sessionIds":["security-authn-1","security-authn-2","security-authn-3","security-authn-4","security-authn-5"],"checkpointSessionId":"security-authn-5","placementSessionIds":["security-authn-5"],"prerequisites":["security-injection"],"skillIds":["skill-security-store-passwords","skill-security-salt-and-slow-hashes","skill-security-issue-session-tokens","skill-security-defend-the-login"],"revision":"sec1"},{"id":"security-authz","courseId":"security","order":3,"title":"Authorization","description":"Knowing who someone is says nothing about what they may touch. Check ownership on every object, stop a user handing themselves a role, and make the default answer no.","sessionIds":["security-authz-1","security-authz-2","security-authz-3","security-authz-4","security-authz-5"],"checkpointSessionId":"security-authz-5","placementSessionIds":["security-authz-5"],"prerequisites":["security-authn"],"skillIds":["skill-security-separate-authn-from-authz","skill-security-check-object-ownership","skill-security-contain-privilege","skill-security-deny-by-default"],"revision":"sec1"},{"id":"security-web","courseId":"security","order":4,"title":"Browser attacks","description":"Tell stored, reflected and DOM XSS apart, escape for the context a value actually lands in, stop a forged cross-site request, and set the handful of response headers that carry their weight.","sessionIds":["security-web-1","security-web-2","security-web-3","security-web-4","security-web-5"],"checkpointSessionId":"security-web-5","placementSessionIds":["security-web-5"],"prerequisites":["security-authz"],"skillIds":["skill-security-recognise-xss","skill-security-escape-for-the-context","skill-security-stop-csrf","skill-security-set-response-headers"],"revision":"sec1"},{"id":"security-secrets","courseId":"security","order":5,"title":"Secrets and crypto","description":"Keep credentials in a store you can rotate, tell hashing from encryption from encoding, say what TLS actually promises, and use randomness that an attacker cannot predict.","sessionIds":["security-secrets-1","security-secrets-2","security-secrets-3","security-secrets-4","security-secrets-5"],"checkpointSessionId":"security-secrets-5","placementSessionIds":["security-secrets-5"],"prerequisites":["security-web"],"skillIds":["skill-security-handle-secrets","skill-security-tell-hashing-from-encryption","skill-security-reason-about-tls","skill-security-use-safe-randomness"],"revision":"sec1"},{"id":"security-supplychain","courseId":"security","order":6,"title":"Dependencies and the supply chain","description":"Most of your code is code you did not write. Follow a vulnerability through a dependency tree, triage an advisory, lock what you install, and give a build only the access it needs.","sessionIds":["security-supplychain-1","security-supplychain-2","security-supplychain-3","security-supplychain-4","security-supplychain-5"],"checkpointSessionId":"security-supplychain-5","placementSessionIds":["security-supplychain-5"],"prerequisites":["security-secrets"],"skillIds":["skill-security-read-a-dependency-tree","skill-security-triage-advisories","skill-security-lock-dependencies","skill-security-limit-ci-privilege"],"revision":"sec1"},{"id":"testing-first","courseId":"testing","order":1,"title":"What a test is","description":"Arrange, act, assert; write an assertion that can fail; test behaviour rather than implementation; write the first test for a function.","sessionIds":["testing-first-1","testing-first-2","testing-first-3","testing-first-4","testing-first-5"],"checkpointSessionId":"testing-first-5","placementSessionIds":["testing-first-5"],"prerequisites":[],"skillIds":["skill-testing-arrange-act-assert","skill-testing-write-assertions","skill-testing-test-behaviour","skill-testing-write-first-test"],"revision":"test1"},{"id":"testing-cases","courseId":"testing","order":2,"title":"Choosing cases","description":"Boundaries and off-by-one, empty and single-element inputs, one case per equivalence class, and the error path nobody writes.","sessionIds":["testing-cases-1","testing-cases-2","testing-cases-3","testing-cases-4","testing-cases-5"],"checkpointSessionId":"testing-cases-5","placementSessionIds":["testing-cases-5"],"prerequisites":["testing-first"],"skillIds":["skill-testing-cover-boundaries","skill-testing-test-edge-inputs","skill-testing-choose-equivalence-classes","skill-testing-test-error-paths"],"revision":"test1"},{"id":"testing-doubles","courseId":"testing","order":3,"title":"Isolating code","description":"Stubs, mocks and fakes and when each is right, dependency injection, the cost of mocking what you do not own, and testing time and randomness.","sessionIds":["testing-doubles-1","testing-doubles-2","testing-doubles-3","testing-doubles-4","testing-doubles-5"],"checkpointSessionId":"testing-doubles-5","placementSessionIds":["testing-doubles-5"],"prerequisites":["testing-cases"],"skillIds":["skill-testing-choose-test-doubles","skill-testing-inject-dependencies","skill-testing-avoid-mocking-others","skill-testing-control-time"],"revision":"test1"},{"id":"testing-suites","courseId":"testing","order":4,"title":"Tests you can live with","description":"Fast versus slow tests and the pyramid, names that explain a failure, shared state between tests, and the real causes of flakiness.","sessionIds":["testing-suites-1","testing-suites-2","testing-suites-3","testing-suites-4","testing-suites-5"],"checkpointSessionId":"testing-suites-5","placementSessionIds":["testing-suites-5"],"prerequisites":["testing-doubles"],"skillIds":["skill-testing-shape-test-pyramid","skill-testing-name-tests","skill-testing-isolate-shared-state","skill-testing-remove-flakiness"],"revision":"test1"},{"id":"testing-refactor","courseId":"testing","order":5,"title":"Changing code safely","description":"Refactor under a green suite, pin unknown code with characterisation tests, move in small reversible steps, and act on the smells that matter.","sessionIds":["testing-refactor-1","testing-refactor-2","testing-refactor-3","testing-refactor-4","testing-refactor-5"],"checkpointSessionId":"testing-refactor-5","placementSessionIds":["testing-refactor-5"],"prerequisites":["testing-suites"],"skillIds":["skill-testing-refactor-under-green","skill-testing-write-characterisation-tests","skill-testing-take-small-steps","skill-testing-spot-code-smells"],"revision":"test1"},{"id":"testing-review","courseId":"testing","order":6,"title":"Craft","description":"Shape a pull request others can review, review for design rather than style, write comments that earn their place, and name well enough to delete the rest.","sessionIds":["testing-review-1","testing-review-2","testing-review-3","testing-review-4","testing-review-5"],"checkpointSessionId":"testing-review-5","placementSessionIds":["testing-review-5"],"prerequisites":["testing-refactor"],"skillIds":["skill-testing-shape-pull-requests","skill-testing-review-for-design","skill-testing-write-useful-comments","skill-testing-name-and-prune-code"],"revision":"test1"}],"skills":[{"id":"skill-request-journey","courseId":"design","unitId":"design-first-system","title":"How a web request works"},{"id":"skill-scale-a-service","courseId":"design","unitId":"design-first-system","title":"Make room for growth"},{"id":"skill-cache-a-read","courseId":"design","unitId":"design-first-system","title":"Give your database a break"},{"id":"skill-lesson-latency-vs-throughput","courseId":"design","unitId":"design-performance","title":"Latency vs Throughput"},{"id":"skill-lesson-performance-metrics","courseId":"design","unitId":"design-performance","title":"Performance Metrics"},{"id":"skill-lesson-bottleneck-analysis","courseId":"design","unitId":"design-performance","title":"Bottleneck Analysis"},{"id":"skill-lesson-advanced-scaling","courseId":"design","unitId":"design-performance","title":"Advanced Scaling Patterns"},{"id":"skill-lesson-reliability-availability","courseId":"design","unitId":"design-performance","title":"Reliability & Availability"},{"id":"skill-lesson-database-fundamentals","courseId":"design","unitId":"design-storage","title":"Database Fundamentals"},{"id":"skill-lesson-data-modeling","courseId":"design","unitId":"design-storage","title":"Data Modeling Basics"},{"id":"skill-lesson-acid-properties","courseId":"design","unitId":"design-storage","title":"ACID Properties"},{"id":"skill-lesson-mysql","courseId":"design","unitId":"design-storage","title":"MySQL"},{"id":"skill-lesson-postgresql","courseId":"design","unitId":"design-storage","title":"PostgreSQL"},{"id":"skill-lesson-mongodb","courseId":"design","unitId":"design-storage","title":"MongoDB"},{"id":"skill-lesson-replication-sharding","courseId":"design","unitId":"design-data-at-scale","title":"Replication & Sharding"},{"id":"skill-lesson-consistent-hashing","courseId":"design","unitId":"design-data-at-scale","title":"Consistent Hashing"},{"id":"skill-lesson-sstable","courseId":"design","unitId":"design-data-at-scale","title":"SSTable & LSM Trees"},{"id":"skill-lesson-cassandra","courseId":"design","unitId":"design-data-at-scale","title":"Apache Cassandra"},{"id":"skill-lesson-dynamodb","courseId":"design","unitId":"design-data-at-scale","title":"Amazon DynamoDB"},{"id":"skill-lesson-redis","courseId":"design","unitId":"design-fast-reads","title":"Redis"},{"id":"skill-lesson-memcached","courseId":"design","unitId":"design-fast-reads","title":"Memcached"},{"id":"skill-lesson-elasticsearch","courseId":"design","unitId":"design-fast-reads","title":"Elasticsearch"},{"id":"skill-lesson-lucene","courseId":"design","unitId":"design-fast-reads","title":"Apache Lucene"},{"id":"skill-lesson-object-storage","courseId":"design","unitId":"design-fast-reads","title":"Object Storage"},{"id":"skill-lesson-cloudfront","courseId":"design","unitId":"design-fast-reads","title":"Amazon CloudFront"},{"id":"skill-lesson-api-design","courseId":"design","unitId":"design-service-interfaces","title":"API Design Principles"},{"id":"skill-lesson-api-paradigms","courseId":"design","unitId":"design-service-interfaces","title":"API Paradigms"},{"id":"skill-lesson-graphql","courseId":"design","unitId":"design-service-interfaces","title":"GraphQL"},{"id":"skill-lesson-grpc","courseId":"design","unitId":"design-service-interfaces","title":"gRPC"},{"id":"skill-lesson-websocket","courseId":"design","unitId":"design-service-interfaces","title":"WebSocket"},{"id":"skill-lesson-http2-http3","courseId":"design","unitId":"design-service-interfaces","title":"HTTP/2 & HTTP/3"},{"id":"skill-lesson-communication-patterns","courseId":"design","unitId":"design-async-systems","title":"Communication Patterns"},{"id":"skill-lesson-fundamentals-message-queues","courseId":"design","unitId":"design-async-systems","title":"Message Queues"},{"id":"skill-lesson-kafka","courseId":"design","unitId":"design-async-systems","title":"Apache Kafka"},{"id":"skill-lesson-rabbitmq","courseId":"design","unitId":"design-async-systems","title":"RabbitMQ"},{"id":"skill-lesson-sqs","courseId":"design","unitId":"design-async-systems","title":"Amazon SQS"},{"id":"skill-lesson-event-driven-architecture","courseId":"design","unitId":"design-async-systems","title":"Event-Driven Architecture"},{"id":"skill-lesson-temporal","courseId":"design","unitId":"design-async-systems","title":"Temporal Workflows"},{"id":"skill-lesson-nginx","courseId":"design","unitId":"design-resilient-services","title":"NGINX"},{"id":"skill-lesson-proxies-load-balancing","courseId":"design","unitId":"design-resilient-services","title":"Proxies & Load Balancing"},{"id":"skill-lesson-rate-limiting-tech","courseId":"design","unitId":"design-resilient-services","title":"Rate Limiting"},{"id":"skill-lesson-circuit-breakers","courseId":"design","unitId":"design-resilient-services","title":"Circuit Breakers"},{"id":"skill-lesson-concurrency","courseId":"design","unitId":"design-resilient-services","title":"Concurrency Patterns"},{"id":"skill-lesson-chaos-engineering","courseId":"design","unitId":"design-resilient-services","title":"Chaos Engineering"},{"id":"skill-lesson-monolith-to-microservices","courseId":"design","unitId":"design-production","title":"Monolith to Microservices"},{"id":"skill-lesson-docker","courseId":"design","unitId":"design-production","title":"Docker"},{"id":"skill-lesson-kubernetes","courseId":"design","unitId":"design-production","title":"Kubernetes"},{"id":"skill-lesson-etcd","courseId":"design","unitId":"design-production","title":"etcd Key-Value Store"},{"id":"skill-lesson-prometheus","courseId":"design","unitId":"design-production","title":"Prometheus"},{"id":"skill-lesson-grafana","courseId":"design","unitId":"design-production","title":"Grafana"},{"id":"skill-lesson-oauth2","courseId":"design","unitId":"design-secure-systems","title":"OAuth 2.0"},{"id":"skill-lesson-jwt","courseId":"design","unitId":"design-secure-systems","title":"JSON Web Tokens (JWT)"},{"id":"skill-lesson-keycloak","courseId":"design","unitId":"design-secure-systems","title":"Keycloak"},{"id":"skill-lesson-vault","courseId":"design","unitId":"design-secure-systems","title":"HashiCorp Vault"},{"id":"skill-lesson-advanced-web-security","courseId":"design","unitId":"design-secure-systems","title":"Advanced Web Security"},{"id":"skill-lesson-system-design-framework","courseId":"design","unitId":"design-design-lab","title":"System Design Interview Framework"},{"id":"skill-lesson-practice-url-shortener","courseId":"design","unitId":"design-design-lab","title":"Design URL Shortener"},{"id":"skill-lesson-practice-chat-system","courseId":"design","unitId":"design-design-lab","title":"Design Chat System"},{"id":"skill-lesson-practice-distributed-cache","courseId":"design","unitId":"design-design-lab","title":"Design Distributed Cache"},{"id":"skill-lesson-practice-payment-system","courseId":"design","unitId":"design-design-lab","title":"Design Payment System"},{"id":"skill-lesson-practice-notification-system","courseId":"design","unitId":"design-design-lab","title":"Design Notification System"},{"id":"skill-lesson-case-study-whatsapp-messaging","courseId":"design","unitId":"design-systems-in-the-wild","title":"WhatsApp Messaging at Scale"},{"id":"skill-lesson-case-study-netflix-streaming","courseId":"design","unitId":"design-systems-in-the-wild","title":"Netflix Streaming Architecture"},{"id":"skill-lesson-case-study-github-collaboration","courseId":"design","unitId":"design-systems-in-the-wild","title":"GitHub Collaboration Platform"},{"id":"skill-lesson-case-study-uber-ridesharing","courseId":"design","unitId":"design-systems-in-the-wild","title":"Uber Ride Sharing Platform"},{"id":"skill-code-capacity","courseId":"coding","unitId":"coding-service-functions","title":"Calculate server capacity"},{"id":"skill-code-routing","courseId":"coding","unitId":"coding-service-functions","title":"Route the next request"},{"id":"skill-code-cache","courseId":"coding","unitId":"coding-service-functions","title":"Read through a cache"},{"id":"skill-code-healthy-router","courseId":"coding","unitId":"coding-service-functions","title":"Build a health-aware router"},{"id":"skill-code-unique-ids","courseId":"coding","unitId":"coding-collections","title":"Remove duplicate IDs"},{"id":"skill-code-count-events","courseId":"coding","unitId":"coding-collections","title":"Count event types"},{"id":"skill-code-group-jobs","courseId":"coding","unitId":"coding-collections","title":"Group work by tenant"},{"id":"skill-code-batch-dedup","courseId":"coding","unitId":"coding-collections","title":"Build a deduplicating batcher"},{"id":"skill-code-link-service","courseId":"coding","unitId":"coding-collections","title":"Build a tiny link service"},{"id":"skill-code-validate-limit","courseId":"coding","unitId":"coding-api-boundaries","title":"Validate a request limit"},{"id":"skill-code-normalize-event","courseId":"coding","unitId":"coding-api-boundaries","title":"Normalize an incoming event"},{"id":"skill-code-page-results","courseId":"coding","unitId":"coding-api-boundaries","title":"Return a bounded page"},{"id":"skill-code-cache-ttl","courseId":"coding","unitId":"coding-api-boundaries","title":"Read a cache with expiry"},{"id":"skill-code-fixed-window","courseId":"coding","unitId":"coding-traffic-control","title":"Apply a fixed-window limit"},{"id":"skill-code-token-bucket","courseId":"coding","unitId":"coding-traffic-control","title":"Refill a token bucket"},{"id":"skill-code-sliding-window","courseId":"coding","unitId":"coding-traffic-control","title":"Count a sliding window"},{"id":"skill-code-admit-batch","courseId":"coding","unitId":"coding-traffic-control","title":"Enforce a per-tenant budget"},{"id":"skill-code-idempotency","courseId":"coding","unitId":"coding-safe-state","title":"Recognize a retried operation"},{"id":"skill-code-version-write","courseId":"coding","unitId":"coding-safe-state","title":"Reject a stale write"},{"id":"skill-code-reconcile-records","courseId":"coding","unitId":"coding-safe-state","title":"Reconcile versioned records"},{"id":"skill-code-apply-events","courseId":"coding","unitId":"coding-safe-state","title":"Apply events exactly once locally"},{"id":"skill-code-backoff","courseId":"coding","unitId":"coding-job-processing","title":"Calculate bounded retry delays"},{"id":"skill-code-ready-jobs","courseId":"coding","unitId":"coding-job-processing","title":"Schedule only ready jobs"},{"id":"skill-code-dead-letter","courseId":"coding","unitId":"coding-job-processing","title":"Separate retries from dead letters"},{"id":"skill-code-worker-plan","courseId":"coding","unitId":"coding-job-processing","title":"Build a bounded worker plan"},{"id":"skill-lesson-llm-intro","courseId":"genai","unitId":"genai-llm-foundations","title":"Introduction to LLMs"},{"id":"skill-lesson-transformers","courseId":"genai","unitId":"genai-llm-foundations","title":"Transformer Architecture"},{"id":"skill-lesson-llms","courseId":"genai","unitId":"genai-llm-foundations","title":"LLM Models & Families"},{"id":"skill-lesson-tokenization-fundamentals","courseId":"genai","unitId":"genai-llm-foundations","title":"Tokenization Fundamentals"},{"id":"skill-lesson-bpe-algorithm","courseId":"genai","unitId":"genai-llm-foundations","title":"BPE Algorithm Deep Dive"},{"id":"skill-lesson-production-tokenization","courseId":"genai","unitId":"genai-llm-foundations","title":"Production Tokenization Systems"},{"id":"skill-lesson-prompt-engineering","courseId":"genai","unitId":"genai-prompt-and-tools","title":"Prompt Engineering"},{"id":"skill-lesson-conversational-ai","courseId":"genai","unitId":"genai-prompt-and-tools","title":"Conversational AI"},{"id":"skill-lesson-function-calling","courseId":"genai","unitId":"genai-prompt-and-tools","title":"Function Calling"},{"id":"skill-lesson-smart-text-completion","courseId":"genai","unitId":"genai-prompt-and-tools","title":"Smart Text Completion"},{"id":"skill-lesson-translation-systems","courseId":"genai","unitId":"genai-prompt-and-tools","title":"Translation Systems"},{"id":"skill-lesson-rag-systems","courseId":"genai","unitId":"genai-retrieval","title":"Building RAG Systems"},{"id":"skill-lesson-rag","courseId":"genai","unitId":"genai-retrieval","title":"RAG Implementation"},{"id":"skill-lesson-advanced-rag","courseId":"genai","unitId":"genai-retrieval","title":"Advanced RAG Patterns"},{"id":"skill-lesson-knowledge-graphs","courseId":"genai","unitId":"genai-retrieval","title":"Knowledge Graphs"},{"id":"skill-lesson-rag-systems-foundation","courseId":"genai","unitId":"genai-retrieval","title":"RAG Systems Foundation"},{"id":"skill-lesson-rag-architecture-deep-dive","courseId":"genai","unitId":"genai-retrieval","title":"RAG Architecture Deep Dive"},{"id":"skill-lesson-vector-database-implementation","courseId":"genai","unitId":"genai-retrieval","title":"Vector Database Implementation"},{"id":"skill-lesson-langchain-production","courseId":"genai","unitId":"genai-agents","title":"LangChain Production"},{"id":"skill-lesson-ai-agents","courseId":"genai","unitId":"genai-agents","title":"AI Agent Architectures"},{"id":"skill-lesson-model-context-protocol","courseId":"genai","unitId":"genai-agents","title":"Model Context Protocol Architecture"},{"id":"skill-lesson-agentic-ai-systems","courseId":"genai","unitId":"genai-agents","title":"Agentic AI Systems Design"},{"id":"skill-lesson-computer-use-agents","courseId":"genai","unitId":"genai-agents","title":"Computer-Use and Browser Agent Systems"},{"id":"skill-lesson-personalized-genai","courseId":"genai","unitId":"genai-agents","title":"Personalized GenAI"},{"id":"skill-lesson-llm-serving","courseId":"genai","unitId":"genai-model-serving","title":"LLM Serving & APIs"},{"id":"skill-lesson-token-management","courseId":"genai","unitId":"genai-model-serving","title":"Token Management"},{"id":"skill-lesson-llm-inference-optimization","courseId":"genai","unitId":"genai-model-serving","title":"LLM Inference Optimization"},{"id":"skill-lesson-ai-gateway-patterns","courseId":"genai","unitId":"genai-model-serving","title":"AI Gateway Patterns"},{"id":"skill-lesson-model-serving-patterns","courseId":"genai","unitId":"genai-model-serving","title":"Model Serving Patterns"},{"id":"skill-lesson-inference-time-scaling","courseId":"genai","unitId":"genai-model-serving","title":"Inference-Time Scaling and Reasoning Budgets"},{"id":"skill-lesson-production-transformer-architecture","courseId":"genai","unitId":"genai-model-serving","title":"Production Transformer Architecture"},{"id":"skill-lesson-fine-tuning-practices","courseId":"genai","unitId":"genai-model-adaptation","title":"Fine-Tuning Best Practices"},{"id":"skill-lesson-lora-fine-tuning","courseId":"genai","unitId":"genai-model-adaptation","title":"LoRA & Parameter-Efficient Fine-Tuning"},{"id":"skill-lesson-raft-fine-tuning","courseId":"genai","unitId":"genai-model-adaptation","title":"RAFT: Retrieval-Augmented Fine-Tuning"},{"id":"skill-lesson-clip-architecture","courseId":"genai","unitId":"genai-vision-and-generation","title":"CLIP Architecture & Applications"},{"id":"skill-lesson-text-to-image","courseId":"genai","unitId":"genai-vision-and-generation","title":"Text-to-Image Generation"},{"id":"skill-lesson-diffusion-models-production","courseId":"genai","unitId":"genai-vision-and-generation","title":"Diffusion Models for Production"},{"id":"skill-lesson-text-to-image-system-design","courseId":"genai","unitId":"genai-vision-and-generation","title":"Text-to-Image System Design"},{"id":"skill-lesson-video-generation","courseId":"genai","unitId":"genai-vision-and-generation","title":"Video Generation"},{"id":"skill-lesson-image-captioning","courseId":"genai","unitId":"genai-multimodal","title":"Image Captioning"},{"id":"skill-lesson-multimodal-ai","courseId":"genai","unitId":"genai-multimodal","title":"Multi-Modal AI APIs & Applications"},{"id":"skill-lesson-advanced-image-captioning","courseId":"genai","unitId":"genai-multimodal","title":"Advanced Image Captioning Systems"},{"id":"skill-lesson-blip3-xgen-mm","courseId":"genai","unitId":"genai-multimodal","title":"BLIP-3 (xGen-MM) Architecture"},{"id":"skill-lesson-internvl3-architecture","courseId":"genai","unitId":"genai-multimodal","title":"InternVL3: Next-Gen Vision-Language Models"},{"id":"skill-lesson-multimodal-moe-systems","courseId":"genai","unitId":"genai-multimodal","title":"Multimodal MoE Systems"},{"id":"skill-lesson-document-parsing-systems","courseId":"genai","unitId":"genai-document-intelligence","title":"Document Parsing: DeDOC & Layout-Parser"},{"id":"skill-lesson-production-document-extraction","courseId":"genai","unitId":"genai-document-intelligence","title":"Production Document Extraction Systems"},{"id":"skill-lesson-laion-aesthetics","courseId":"genai","unitId":"genai-document-intelligence","title":"LAION Aesthetics & Quality Scoring"},{"id":"skill-lesson-evaluation-benchmarks-comprehensive","courseId":"genai","unitId":"genai-evaluation","title":"Comprehensive Evaluation Benchmarks"},{"id":"skill-lesson-llm-as-judge-evaluation","courseId":"genai","unitId":"genai-evaluation","title":"LLM-as-Judge Evaluation"},{"id":"skill-lesson-long-context-evaluation","courseId":"genai","unitId":"genai-evaluation","title":"Long-Context Evaluation"},{"id":"skill-lesson-agentic-ai-evaluation","courseId":"genai","unitId":"genai-evaluation","title":"Agentic AI Evaluation"},{"id":"skill-lesson-production-evaluation-pipelines","courseId":"genai","unitId":"genai-evaluation","title":"Production Evaluation Pipelines"},{"id":"skill-lesson-evaluation-platforms","courseId":"genai","unitId":"genai-evaluation","title":"LLM Evaluation Platforms & Tools"},{"id":"skill-lesson-ai-evaluation-drift","courseId":"genai","unitId":"genai-evaluation","title":"AI Evaluation Drift"},{"id":"skill-lesson-common-sense-reasoning-benchmarks","courseId":"genai","unitId":"genai-evaluation-domains","title":"Common Sense Reasoning: PIQA, HellaSwag & More"},{"id":"skill-lesson-world-knowledge-benchmarks","courseId":"genai","unitId":"genai-evaluation-domains","title":"World Knowledge: TriviaQA, NQ & SQuAD"},{"id":"skill-lesson-mathematical-reasoning-benchmarks","courseId":"genai","unitId":"genai-evaluation-domains","title":"Mathematical Reasoning: MATH & GSM8K"},{"id":"skill-lesson-code-generation-benchmarks","courseId":"genai","unitId":"genai-evaluation-domains","title":"Code Generation: HumanEval & MBPP"},{"id":"skill-lesson-composite-benchmarks-mmlu","courseId":"genai","unitId":"genai-evaluation-domains","title":"Composite Benchmarks: MMLU, MMMU & AGIEval"},{"id":"skill-lesson-lmsys-arena-evaluation","courseId":"genai","unitId":"genai-evaluation-domains","title":"LMSYS Chatbot Arena: Human Preference"},{"id":"skill-lesson-ai-safety","courseId":"genai","unitId":"genai-safety","title":"AI Safety & Guardrails"},{"id":"skill-lesson-safety-evaluation","courseId":"genai","unitId":"genai-safety","title":"Safety & Bias Evaluation"},{"id":"skill-lesson-adversarial-testing","courseId":"genai","unitId":"genai-safety","title":"Adversarial Testing"},{"id":"skill-lesson-safety-evaluation-advanced","courseId":"genai","unitId":"genai-safety","title":"Advanced Safety Evaluation"},{"id":"skill-lesson-toxigen-hatecheck-evaluation","courseId":"genai","unitId":"genai-safety","title":"ToxiGen & HateCheck: Bias Detection"},{"id":"skill-lesson-social-bias-measurement","courseId":"genai","unitId":"genai-safety","title":"Social Bias: CrowS-pairs, BBQ & BOLD"},{"id":"skill-lesson-truthfulqa-evaluation","courseId":"genai","unitId":"genai-safety","title":"TruthfulQA: Truthfulness Evaluation"},{"id":"skill-lesson-adversarial-robustness-evaluation","courseId":"genai","unitId":"genai-safety","title":"Adversarial Robustness: AdvGLUE & TextFooler"},{"id":"skill-lesson-genai-monitoring","courseId":"genai","unitId":"genai-ai-operations","title":"GenAI Monitoring"},{"id":"skill-lesson-production-deployment","courseId":"genai","unitId":"genai-ai-operations","title":"Production Deployment"},{"id":"skill-lesson-agentic-ai-security","courseId":"genai","unitId":"genai-ai-operations","title":"Agentic AI Security"},{"id":"skill-lesson-ai-governance-regulation","courseId":"genai","unitId":"genai-ai-operations","title":"AI Governance and Regulation Engineering"},{"id":"skill-lesson-genai-system-design-process","courseId":"genai","unitId":"genai-genai-design","title":"GenAI System Design Process"},{"id":"skill-lesson-genai-interview-framework","courseId":"genai","unitId":"genai-genai-design","title":"GenAI System Design Interview Framework"},{"id":"skill-lesson-gmail-smart-compose-architecture","courseId":"genai","unitId":"genai-genai-design","title":"Gmail Smart Compose Architecture"},{"id":"skill-lesson-ml-fundamentals","courseId":"ml","unitId":"ml-ml-foundations","title":"ML Fundamentals"},{"id":"skill-lesson-discriminative-vs-generative","courseId":"ml","unitId":"ml-ml-foundations","title":"Discriminative vs Generative Models"},{"id":"skill-lesson-ml-problem-framing","courseId":"ml","unitId":"ml-ml-foundations","title":"ML Problem Framing"},{"id":"skill-lesson-ml-systems-design","courseId":"ml","unitId":"ml-ml-foundations","title":"ML Systems Design"},{"id":"skill-lesson-model-evaluation","courseId":"ml","unitId":"ml-ml-foundations","title":"Model Evaluation & Testing"},{"id":"skill-lesson-data-pipeline-design","courseId":"ml","unitId":"ml-data-and-features","title":"Data Pipeline Design"},{"id":"skill-lesson-data-pipelines","courseId":"ml","unitId":"ml-data-and-features","title":"Data Pipelines"},{"id":"skill-lesson-training-data-management","courseId":"ml","unitId":"ml-data-and-features","title":"Training Data Management"},{"id":"skill-lesson-feature-engineering","courseId":"ml","unitId":"ml-data-and-features","title":"Feature Engineering"},{"id":"skill-lesson-ml-datasets-deep-dive","courseId":"ml","unitId":"ml-data-and-features","title":"ML Datasets: Deep Dive"},{"id":"skill-lesson-data-preparation","courseId":"ml","unitId":"ml-data-and-features","title":"Advanced ML Data Preparation"},{"id":"skill-lesson-pandas-ml","courseId":"ml","unitId":"ml-data-and-features","title":"Pandas for ML Pipelines"},{"id":"skill-lesson-pretraining-data-sources","courseId":"ml","unitId":"ml-data-quality","title":"Web-Scale Data Sources"},{"id":"skill-lesson-data-quality-filtering","courseId":"ml","unitId":"ml-data-quality","title":"Data Quality & Filtering"},{"id":"skill-lesson-demonstration-data","courseId":"ml","unitId":"ml-data-quality","title":"Demonstration Data Curation"},{"id":"skill-lesson-document-parsing","courseId":"ml","unitId":"ml-data-quality","title":"Document Parsing Fundamentals"},{"id":"skill-lesson-layout-parser","courseId":"ml","unitId":"ml-data-quality","title":"Layout-Parser Systems"},{"id":"skill-lesson-dedoc-systems","courseId":"ml","unitId":"ml-data-quality","title":"Dedoc Production Systems"},{"id":"skill-lesson-model-training","courseId":"ml","unitId":"ml-training","title":"Model Training"},{"id":"skill-lesson-shap-lime-explainability","courseId":"ml","unitId":"ml-training","title":"SHAP & LIME Explainability"},{"id":"skill-lesson-llm-fundamentals","courseId":"ml","unitId":"ml-training","title":"LLM Fundamentals"},{"id":"skill-lesson-policy-gradient-theorem","courseId":"ml","unitId":"ml-training","title":"Policy Gradient Theorem & Algorithms"},{"id":"skill-lesson-rlhf","courseId":"ml","unitId":"ml-training","title":"RLHF"},{"id":"skill-lesson-reasoning-evaluation","courseId":"ml","unitId":"ml-ml-evaluation","title":"Reasoning Evaluation Suites"},{"id":"skill-lesson-knowledge-evaluation","courseId":"ml","unitId":"ml-ml-evaluation","title":"Knowledge & Comprehension Testing"},{"id":"skill-lesson-composite-benchmarks","courseId":"ml","unitId":"ml-ml-evaluation","title":"Composite Benchmarks"},{"id":"skill-lesson-ab-testing","courseId":"ml","unitId":"ml-ml-evaluation","title":"A/B Testing"},{"id":"skill-lesson-model-serving","courseId":"ml","unitId":"ml-efficient-models","title":"Model Serving"},{"id":"skill-lesson-model-quantization","courseId":"ml","unitId":"ml-efficient-models","title":"Model Quantization Deep Dive"},{"id":"skill-lesson-knowledge-distillation","courseId":"ml","unitId":"ml-efficient-models","title":"Knowledge Distillation & Model Compression"},{"id":"skill-lesson-model-compression-techniques","courseId":"ml","unitId":"ml-efficient-models","title":"Model Compression Techniques"},{"id":"skill-lesson-flashattention-memory-optimization","courseId":"ml","unitId":"ml-efficient-models","title":"FlashAttention & Memory Optimization"},{"id":"skill-lesson-data-distribution-shifts","courseId":"ml","unitId":"ml-ml-operations","title":"Data Distribution Shifts"},{"id":"skill-lesson-mlops-monitoring","courseId":"ml","unitId":"ml-ml-operations","title":"MLOps Monitoring"},{"id":"skill-lesson-continual-learning","courseId":"ml","unitId":"ml-ml-operations","title":"Continual Learning"},{"id":"skill-lesson-human-in-the-loop-ml","courseId":"ml","unitId":"ml-ml-operations","title":"Human-in-the-Loop ML"},{"id":"skill-lesson-edge-ml-deployment","courseId":"ml","unitId":"ml-ml-operations","title":"Edge ML Deployment"},{"id":"skill-lesson-distributed-training-advanced","courseId":"ml","unitId":"ml-distributed-ml","title":"Advanced Distributed Training"},{"id":"skill-lesson-mixture-of-experts","courseId":"ml","unitId":"ml-distributed-ml","title":"Mixture of Experts (MoE)"},{"id":"skill-lesson-real-time-ml-inference","courseId":"ml","unitId":"ml-distributed-ml","title":"Real-time ML Inference Systems"},{"id":"skill-lesson-unified-ai-platform-architecture","courseId":"ml","unitId":"ml-distributed-ml","title":"Unified AI Platform Architecture"},{"id":"skill-lesson-serverless-mlops","courseId":"ml","unitId":"ml-distributed-ml","title":"Serverless MLOps Architecture"},{"id":"skill-lesson-computer-vision-systems","courseId":"ml","unitId":"ml-perception-and-language","title":"Computer Vision Systems Design"},{"id":"skill-lesson-nlp-systems-architecture","courseId":"ml","unitId":"ml-perception-and-language","title":"NLP Systems Architecture & Scaling"},{"id":"skill-lesson-recommender-systems-advanced","courseId":"ml","unitId":"ml-perception-and-language","title":"Advanced Recommender Systems Architecture"},{"id":"skill-lesson-advanced-search-systems","courseId":"ml","unitId":"ml-perception-and-language","title":"Advanced Search Systems Architecture"},{"id":"skill-lesson-multi-modal-ai-systems","courseId":"ml","unitId":"ml-perception-and-language","title":"Multi-Modal AI Systems"},{"id":"skill-lesson-healthcare-ai","courseId":"ml","unitId":"ml-ml-applications","title":"Healthcare AI Systems"},{"id":"skill-lesson-financial-ml","courseId":"ml","unitId":"ml-ml-applications","title":"Financial ML"},{"id":"skill-lesson-autonomous-systems","courseId":"ml","unitId":"ml-ml-applications","title":"Autonomous Systems"},{"id":"skill-lesson-scientific-ml","courseId":"ml","unitId":"ml-ml-applications","title":"Scientific ML"},{"id":"skill-lesson-real-time-analytics-systems","courseId":"ml","unitId":"ml-ml-applications","title":"Real-Time Analytics Systems"},{"id":"skill-lesson-ai-safety-guardrails-systems","courseId":"ml","unitId":"ml-ml-applications","title":"AI Safety and Guardrails Systems"},{"id":"skill-lesson-advanced-ai-agents","courseId":"ml","unitId":"ml-ml-frontiers","title":"Advanced AI Agents"},{"id":"skill-lesson-advanced-reasoning","courseId":"ml","unitId":"ml-ml-frontiers","title":"Advanced Reasoning Systems"},{"id":"skill-lesson-neural-architecture-search","courseId":"ml","unitId":"ml-ml-frontiers","title":"Neural Architecture Search (NAS)"},{"id":"skill-lesson-federated-learning","courseId":"ml","unitId":"ml-ml-frontiers","title":"Federated Learning Systems"},{"id":"skill-lesson-world-models","courseId":"ml","unitId":"ml-ml-frontiers","title":"World Models for AI Systems"},{"id":"skill-lesson-robotics-agents","courseId":"ml","unitId":"ml-ml-frontiers","title":"Robotics Agent Systems"},{"id":"skill-lesson-neuromorphic-computing","courseId":"ml","unitId":"ml-ml-frontiers","title":"Neuromorphic Computing"},{"id":"skill-lesson-quantum-ml","courseId":"ml","unitId":"ml-ml-frontiers","title":"Quantum ML"},{"id":"skill-python-print-values","courseId":"python","unitId":"python-hello","title":"Print values with print()"},{"id":"skill-python-assign-variables","courseId":"python","unitId":"python-hello","title":"Assign and reassign variables"},{"id":"skill-python-use-number-types","courseId":"python","unitId":"python-hello","title":"Calculate with ints and floats"},{"id":"skill-python-build-strings","courseId":"python","unitId":"python-hello","title":"Build strings with quotes, + and *"},{"id":"skill-python-compare-values","courseId":"python","unitId":"python-decisions","title":"Compare values with == and <"},{"id":"skill-python-branch-with-if","courseId":"python","unitId":"python-decisions","title":"Branch with if, elif and else"},{"id":"skill-python-combine-conditions","courseId":"python","unitId":"python-decisions","title":"Combine conditions with and, or, not"},{"id":"skill-python-judge-truthiness","courseId":"python","unitId":"python-decisions","title":"Judge which values are truthy"},{"id":"skill-python-loop-with-for","courseId":"python","unitId":"python-repeating","title":"Loop over a sequence with for"},{"id":"skill-python-use-range","courseId":"python","unitId":"python-repeating","title":"Count with range()"},{"id":"skill-python-loop-with-while","courseId":"python","unitId":"python-repeating","title":"Repeat with while until it ends"},{"id":"skill-python-control-loop-flow","courseId":"python","unitId":"python-repeating","title":"Steer a loop with break and continue"},{"id":"skill-python-index-lists","courseId":"python","unitId":"python-collections","title":"Index lists from both ends"},{"id":"skill-python-slice-lists","courseId":"python","unitId":"python-collections","title":"Slice lists with [start:stop]"},{"id":"skill-python-mutate-lists","courseId":"python","unitId":"python-collections","title":"Change lists with append, insert and pop"},{"id":"skill-python-alias-lists","courseId":"python","unitId":"python-collections","title":"Tell a shared list from a copy"},{"id":"skill-python-read-dicts","courseId":"python","unitId":"python-dicts","title":"Read values by key and with get()"},{"id":"skill-python-update-dicts","courseId":"python","unitId":"python-dicts","title":"Add, change and remove pairs"},{"id":"skill-python-loop-dicts","courseId":"python","unitId":"python-dicts","title":"Loop over keys, values and items"},{"id":"skill-python-use-sets","courseId":"python","unitId":"python-dicts","title":"Keep values unique with a set"},{"id":"skill-python-define-functions","courseId":"python","unitId":"python-functions","title":"Define and call a function with def"},{"id":"skill-python-pass-arguments","courseId":"python","unitId":"python-functions","title":"Pass positional, keyword and default arguments"},{"id":"skill-python-return-values","courseId":"python","unitId":"python-functions","title":"Return a value instead of printing it"},{"id":"skill-python-scope-names","courseId":"python","unitId":"python-functions","title":"Tell a local name from an outer one"},{"id":"skill-python-slice-strings","courseId":"python","unitId":"python-strings","title":"Index and slice a string that cannot change"},{"id":"skill-python-split-join-strings","courseId":"python","unitId":"python-strings","title":"Split, join, strip and replace"},{"id":"skill-python-format-strings","courseId":"python","unitId":"python-strings","title":"Format values with f-strings"},{"id":"skill-python-search-strings","courseId":"python","unitId":"python-strings","title":"Search text with in, find and case methods"},{"id":"skill-python-read-tracebacks","courseId":"python","unitId":"python-errors","title":"Read a traceback and name the error"},{"id":"skill-python-catch-exceptions","courseId":"python","unitId":"python-errors","title":"Catch a specific exception with try/except"},{"id":"skill-python-use-else-finally","courseId":"python","unitId":"python-errors","title":"Use else and finally around a try"},{"id":"skill-python-raise-errors","courseId":"python","unitId":"python-errors","title":"Raise an error the caller can catch"},{"id":"skill-javascript-declare-variables","courseId":"javascript","unitId":"javascript-values","title":"Declare variables with let and const"},{"id":"skill-javascript-identify-types","courseId":"javascript","unitId":"javascript-values","title":"Identify a value's type"},{"id":"skill-javascript-convert-types","courseId":"javascript","unitId":"javascript-values","title":"Convert between strings and numbers"},{"id":"skill-javascript-use-operators","courseId":"javascript","unitId":"javascript-values","title":"Use arithmetic and Math operators"},{"id":"skill-javascript-define-functions","courseId":"javascript","unitId":"javascript-functions","title":"Define functions and arrow functions"},{"id":"skill-javascript-pass-arguments","courseId":"javascript","unitId":"javascript-functions","title":"Pass parameters and default values"},{"id":"skill-javascript-scope-variables","courseId":"javascript","unitId":"javascript-functions","title":"Reason about block scope and closures"},{"id":"skill-javascript-avoid-hoisting-traps","courseId":"javascript","unitId":"javascript-functions","title":"Avoid hoisting and return traps"},{"id":"skill-javascript-transform-arrays","courseId":"javascript","unitId":"javascript-arrays","title":"Transform arrays with map and filter"},{"id":"skill-javascript-search-arrays","courseId":"javascript","unitId":"javascript-arrays","title":"Search arrays with find, some and every"},{"id":"skill-javascript-reduce-arrays","courseId":"javascript","unitId":"javascript-arrays","title":"Fold an array with reduce"},{"id":"skill-javascript-sort-arrays","courseId":"javascript","unitId":"javascript-arrays","title":"Sort arrays with a comparator"},{"id":"skill-javascript-access-properties","courseId":"javascript","unitId":"javascript-objects","title":"Read and write object properties"},{"id":"skill-javascript-destructure-values","courseId":"javascript","unitId":"javascript-objects","title":"Destructure and spread objects"},{"id":"skill-javascript-copy-references","courseId":"javascript","unitId":"javascript-objects","title":"Tell a reference from a copy"},{"id":"skill-javascript-use-json","courseId":"javascript","unitId":"javascript-objects","title":"Convert objects with JSON"},{"id":"skill-javascript-compare-values","courseId":"javascript","unitId":"javascript-control-flow","title":"Compare values with === and =="},{"id":"skill-javascript-judge-truthiness","courseId":"javascript","unitId":"javascript-control-flow","title":"Judge truthy and falsy values"},{"id":"skill-javascript-choose-defaults","courseId":"javascript","unitId":"javascript-control-flow","title":"Choose defaults with ?? and ?."},{"id":"skill-javascript-branch-flow","courseId":"javascript","unitId":"javascript-control-flow","title":"Branch with ternaries, switch and returns"},{"id":"skill-javascript-build-strings","courseId":"javascript","unitId":"javascript-strings","title":"Build strings with template literals"},{"id":"skill-javascript-cut-strings","courseId":"javascript","unitId":"javascript-strings","title":"Cut strings with slice, split and join"},{"id":"skill-javascript-search-strings","courseId":"javascript","unitId":"javascript-strings","title":"Search text with includes and indexOf"},{"id":"skill-javascript-clean-strings","courseId":"javascript","unitId":"javascript-strings","title":"Clean text with trim, case and replace"},{"id":"skill-javascript-use-callbacks","courseId":"javascript","unitId":"javascript-async","title":"Read callbacks and promises"},{"id":"skill-javascript-chain-promises","courseId":"javascript","unitId":"javascript-async","title":"Chain promises with then and catch"},{"id":"skill-javascript-await-promises","courseId":"javascript","unitId":"javascript-async","title":"Await promises with try and catch"},{"id":"skill-javascript-order-event-loop","courseId":"javascript","unitId":"javascript-async","title":"Order sync code, promises and timers"},{"id":"skill-javascript-throw-errors","courseId":"javascript","unitId":"javascript-modern","title":"Throw and catch errors"},{"id":"skill-javascript-unpack-values","courseId":"javascript","unitId":"javascript-modern","title":"Destructure with defaults and renaming"},{"id":"skill-javascript-spread-values","courseId":"javascript","unitId":"javascript-modern","title":"Spread and gather with three dots"},{"id":"skill-javascript-write-classes","courseId":"javascript","unitId":"javascript-modern","title":"Write a class and export it"},{"id":"skill-dsa-count-steps","courseId":"dsa","unitId":"dsa-big-o","title":"Count the steps a loop performs"},{"id":"skill-dsa-name-the-class","courseId":"dsa","unitId":"dsa-big-o","title":"Name the complexity class of a piece of code"},{"id":"skill-dsa-compare-growth","courseId":"dsa","unitId":"dsa-big-o","title":"Compare growth rates as the input grows"},{"id":"skill-dsa-index-arrays","courseId":"dsa","unitId":"dsa-arrays","title":"Read an array by index and scan it once"},{"id":"skill-dsa-walk-two-pointers","courseId":"dsa","unitId":"dsa-arrays","title":"Walk an array with two pointers"},{"id":"skill-dsa-slide-windows","courseId":"dsa","unitId":"dsa-arrays","title":"Slide a window instead of rebuilding it"},{"id":"skill-dsa-weigh-shift-cost","courseId":"dsa","unitId":"dsa-arrays","title":"Weigh the cost of moving elements around"},{"id":"skill-dsa-look-up-by-key","courseId":"dsa","unitId":"dsa-hash-maps","title":"Look a value up by key in constant time"},{"id":"skill-dsa-count-with-maps","courseId":"dsa","unitId":"dsa-hash-maps","title":"Count and group items with a Map"},{"id":"skill-dsa-track-seen","courseId":"dsa","unitId":"dsa-hash-maps","title":"Track what you have already seen with a Set"},{"id":"skill-dsa-judge-key-identity","courseId":"dsa","unitId":"dsa-hash-maps","title":"Judge when two keys are the same key"},{"id":"skill-dsa-push-and-pop","courseId":"dsa","unitId":"dsa-stacks-queues","title":"Push and pop a stack in the right order"},{"id":"skill-dsa-match-brackets","courseId":"dsa","unitId":"dsa-stacks-queues","title":"Match nested brackets with a stack"},{"id":"skill-dsa-serve-in-order","courseId":"dsa","unitId":"dsa-stacks-queues","title":"Serve a queue in arrival order"},{"id":"skill-dsa-pick-the-shape","courseId":"dsa","unitId":"dsa-stacks-queues","title":"Pick between a stack and a queue"},{"id":"skill-dsa-follow-next","courseId":"dsa","unitId":"dsa-linked-lists","title":"Follow next pointers from the head"},{"id":"skill-dsa-rewire-nodes","courseId":"dsa","unitId":"dsa-linked-lists","title":"Insert and delete by rewiring next pointers"},{"id":"skill-dsa-reverse-a-list","courseId":"dsa","unitId":"dsa-linked-lists","title":"Reverse a list one value at a time"},{"id":"skill-dsa-weigh-list-cost","courseId":"dsa","unitId":"dsa-linked-lists","title":"Weigh a linked list against an array"},{"id":"skill-dsa-find-the-base-case","courseId":"dsa","unitId":"dsa-recursion","title":"Find the base case that stops a recursion"},{"id":"skill-dsa-trace-the-call-stack","courseId":"dsa","unitId":"dsa-recursion","title":"Trace the call stack of a recursive function"},{"id":"skill-dsa-swap-loop-and-recursion","courseId":"dsa","unitId":"dsa-recursion","title":"Swap a recursion for a loop and back"},{"id":"skill-dsa-memoise-repeats","courseId":"dsa","unitId":"dsa-recursion","title":"Memoise repeated recursive calls"},{"id":"skill-dsa-read-tree-shape","courseId":"dsa","unitId":"dsa-trees","title":"Read a tree’s height, depth and leaves"},{"id":"skill-dsa-traverse-a-tree","courseId":"dsa","unitId":"dsa-trees","title":"Walk a tree in pre, in and post order"},{"id":"skill-dsa-search-a-bst","courseId":"dsa","unitId":"dsa-trees","title":"Search a binary search tree by comparison"},{"id":"skill-dsa-weigh-tree-balance","courseId":"dsa","unitId":"dsa-trees","title":"Weigh what balance buys a tree"},{"id":"skill-dsa-read-adjacency","courseId":"dsa","unitId":"dsa-graphs","title":"Read a graph from an adjacency list"},{"id":"skill-dsa-order-bfs-dfs","courseId":"dsa","unitId":"dsa-graphs","title":"Order the nodes BFS and DFS visit"},{"id":"skill-dsa-guard-with-visited","courseId":"dsa","unitId":"dsa-graphs","title":"Guard a traversal with a visited set"},{"id":"skill-dsa-find-shortest-hops","courseId":"dsa","unitId":"dsa-graphs","title":"Find the fewest hops with BFS"},{"id":"skill-sql-read-a-table","courseId":"sql","unitId":"sql-tables","title":"Read rows, columns and a schema"},{"id":"skill-sql-insert-rows","courseId":"sql","unitId":"sql-tables","title":"Add rows with INSERT INTO"},{"id":"skill-sql-name-column-types","courseId":"sql","unitId":"sql-tables","title":"Tell a column type from a value"},{"id":"skill-sql-use-primary-keys","courseId":"sql","unitId":"sql-tables","title":"Identify a row by its primary key"},{"id":"skill-sql-select-columns","courseId":"sql","unitId":"sql-select","title":"Choose the columns a query returns"},{"id":"skill-sql-filter-with-where","courseId":"sql","unitId":"sql-select","title":"Filter rows with WHERE, AND, OR and NOT"},{"id":"skill-sql-compare-with-null","courseId":"sql","unitId":"sql-select","title":"Test for NULL with IS NULL"},{"id":"skill-sql-sort-and-limit","courseId":"sql","unitId":"sql-select","title":"Sort, cut and de-duplicate a result"},{"id":"skill-sql-link-with-foreign-keys","courseId":"sql","unitId":"sql-joins","title":"Link tables with primary and foreign keys"},{"id":"skill-sql-join-matching-rows","courseId":"sql","unitId":"sql-joins","title":"Pair rows with an INNER JOIN"},{"id":"skill-sql-keep-unmatched-rows","courseId":"sql","unitId":"sql-joins","title":"Keep unmatched rows with a LEFT JOIN"},{"id":"skill-sql-count-join-rows","courseId":"sql","unitId":"sql-joins","title":"Count the rows a join returns"},{"id":"skill-sql-summarize-with-aggregates","courseId":"sql","unitId":"sql-aggregates","title":"Summarise rows with COUNT, SUM, AVG, MIN and MAX"},{"id":"skill-sql-count-with-nulls","courseId":"sql","unitId":"sql-aggregates","title":"Tell COUNT(*) apart from COUNT(column)"},{"id":"skill-sql-group-rows","courseId":"sql","unitId":"sql-aggregates","title":"Collapse rows into groups with GROUP BY"},{"id":"skill-sql-filter-groups-with-having","courseId":"sql","unitId":"sql-aggregates","title":"Filter groups with HAVING, rows with WHERE"},{"id":"skill-sql-explain-an-index","courseId":"sql","unitId":"sql-indexes","title":"Say what an index is and why a lookup gets fast"},{"id":"skill-sql-weigh-index-cost","courseId":"sql","unitId":"sql-indexes","title":"Weigh what an index costs on every write"},{"id":"skill-sql-spot-unusable-indexes","courseId":"sql","unitId":"sql-indexes","title":"Spot a query that cannot use its index"},{"id":"skill-sql-read-a-query-plan","courseId":"sql","unitId":"sql-indexes","title":"Read a plan and build a covering index"},{"id":"skill-sql-explain-acid","courseId":"sql","unitId":"sql-transactions","title":"Say what ACID promises, in plain terms"},{"id":"skill-sql-run-a-transaction","courseId":"sql","unitId":"sql-transactions","title":"Group writes with BEGIN, COMMIT and ROLLBACK"},{"id":"skill-sql-spot-isolation-bugs","courseId":"sql","unitId":"sql-transactions","title":"Spot a dirty read, a non-repeatable read and a lost update"},{"id":"skill-sql-normalize-a-schema","courseId":"sql","unitId":"sql-transactions","title":"Store each fact once, and know when to copy it back"},{"id":"skill-typescript-annotate-values","courseId":"typescript","unitId":"typescript-types","title":"Annotate values with primitive types"},{"id":"skill-typescript-read-inference","courseId":"typescript","unitId":"typescript-types","title":"Read what TypeScript infers"},{"id":"skill-typescript-handle-unknown","courseId":"typescript","unitId":"typescript-types","title":"Choose unknown over any"},{"id":"skill-typescript-use-literal-types","courseId":"typescript","unitId":"typescript-types","title":"Keep literal types narrow"},{"id":"skill-typescript-declare-interfaces","courseId":"typescript","unitId":"typescript-objects","title":"Declare interfaces and type aliases"},{"id":"skill-typescript-mark-optional-readonly","courseId":"typescript","unitId":"typescript-objects","title":"Mark properties optional and readonly"},{"id":"skill-typescript-index-objects","courseId":"typescript","unitId":"typescript-objects","title":"Open a type with an index signature"},{"id":"skill-typescript-check-shapes","courseId":"typescript","unitId":"typescript-objects","title":"Check object shapes structurally"},{"id":"skill-typescript-build-unions","courseId":"typescript","unitId":"typescript-unions","title":"Build and read union types"},{"id":"skill-typescript-narrow-types","courseId":"typescript","unitId":"typescript-unions","title":"Narrow with typeof, in and truthiness"},{"id":"skill-typescript-tag-unions","courseId":"typescript","unitId":"typescript-unions","title":"Discriminate a union with a tag"},{"id":"skill-typescript-exhaust-cases","courseId":"typescript","unitId":"typescript-unions","title":"Prove exhaustiveness with never"},{"id":"skill-typescript-type-signatures","courseId":"typescript","unitId":"typescript-functions","title":"Type a function's parameters and return"},{"id":"skill-typescript-default-params","courseId":"typescript","unitId":"typescript-functions","title":"Type optional and default parameters"},{"id":"skill-typescript-return-void","courseId":"typescript","unitId":"typescript-functions","title":"Tell void from undefined"},{"id":"skill-typescript-type-callbacks","courseId":"typescript","unitId":"typescript-functions","title":"Type callbacks and function types"},{"id":"skill-typescript-write-generics","courseId":"typescript","unitId":"typescript-generics","title":"Write a generic function"},{"id":"skill-typescript-constrain-generics","courseId":"typescript","unitId":"typescript-generics","title":"Constrain a type parameter with extends"},{"id":"skill-typescript-declare-generic-types","courseId":"typescript","unitId":"typescript-generics","title":"Declare generic interfaces and aliases"},{"id":"skill-typescript-judge-generics","courseId":"typescript","unitId":"typescript-generics","title":"Judge when a generic is overkill"},{"id":"skill-typescript-apply-utility-types","courseId":"typescript","unitId":"typescript-practical","title":"Apply Partial, Pick, Omit and Record"},{"id":"skill-typescript-type-api-data","courseId":"typescript","unitId":"typescript-practical","title":"Type an API response at the boundary"},{"id":"skill-typescript-limit-assertions","courseId":"typescript","unitId":"typescript-practical","title":"Limit as assertions"},{"id":"skill-typescript-handle-null","courseId":"typescript","unitId":"typescript-practical","title":"Handle null and undefined under strict"},{"id":"skill-web-read-a-request","courseId":"web","unitId":"web-http","title":"Read a request and a response line by line"},{"id":"skill-web-choose-a-method","courseId":"web","unitId":"web-http","title":"Choose the method that matches the effect"},{"id":"skill-web-read-status-codes","courseId":"web","unitId":"web-http","title":"Read a status code and its family"},{"id":"skill-web-judge-safe-and-idempotent","courseId":"web","unitId":"web-http","title":"Tell a safe method from an idempotent one"},{"id":"skill-web-model-resources","courseId":"web","unitId":"web-rest","title":"Name resources and shape their URLs"},{"id":"skill-web-place-parameters","courseId":"web","unitId":"web-rest","title":"Put each value in the path, query or body"},{"id":"skill-web-answer-with-status","courseId":"web","unitId":"web-rest","title":"Answer a create, update or delete correctly"},{"id":"skill-web-page-and-version","courseId":"web","unitId":"web-rest","title":"Page a collection, version an API, shape an error"},{"id":"skill-web-read-json-shapes","courseId":"web","unitId":"web-json","title":"Tell a JSON object from an array, and a value from its type"},{"id":"skill-web-navigate-nested-json","courseId":"web","unitId":"web-json","title":"Reach a value inside nested JSON"},{"id":"skill-web-tell-null-from-missing","courseId":"web","unitId":"web-json","title":"Tell null, empty and missing apart"},{"id":"skill-web-handle-bad-payloads","courseId":"web","unitId":"web-json","title":"Answer a payload that will not parse or will not do"},{"id":"skill-web-run-a-session","courseId":"web","unitId":"web-auth","title":"Keep a user signed in with a cookie session"},{"id":"skill-web-read-a-jwt","courseId":"web","unitId":"web-auth","title":"Say what a JWT proves and what it does not"},{"id":"skill-web-handle-expiry","courseId":"web","unitId":"web-auth","title":"Handle an expired token with a refresh"},{"id":"skill-web-protect-secrets","courseId":"web","unitId":"web-auth","title":"Keep secrets off the client and traffic on HTTPS"},{"id":"skill-web-trace-a-page-load","courseId":"web","unitId":"web-browser","title":"Trace the requests and redirects a page makes"},{"id":"skill-web-apply-same-origin","courseId":"web","unitId":"web-browser","title":"Decide whether two URLs share an origin"},{"id":"skill-web-run-a-preflight","courseId":"web","unitId":"web-browser","title":"Work out when the browser preflights"},{"id":"skill-web-read-cache-headers","courseId":"web","unitId":"web-browser","title":"Read the caching headers on a response"},{"id":"skill-web-handle-timeouts","courseId":"web","unitId":"web-reliability","title":"Set a deadline and read what a timeout means"},{"id":"skill-web-retry-with-backoff","courseId":"web","unitId":"web-reliability","title":"Retry only what is safe, and only with backoff"},{"id":"skill-web-use-idempotency-keys","courseId":"web","unitId":"web-reliability","title":"Make a repeated write harmless with a key"},{"id":"skill-web-respect-rate-limits","courseId":"web","unitId":"web-reliability","title":"Respect a rate limit and read an error response"},{"id":"skill-git-stage-changes","courseId":"git","unitId":"git-basics","title":"Move a change into the staging area with git add"},{"id":"skill-git-read-status","courseId":"git","unitId":"git-basics","title":"Read git status and git diff"},{"id":"skill-git-record-commits","courseId":"git","unitId":"git-basics","title":"Record a commit and read git log"},{"id":"skill-git-write-messages","courseId":"git","unitId":"git-basics","title":"Write a commit message worth reading"},{"id":"skill-git-create-branches","courseId":"git","unitId":"git-branches","title":"Create and delete branches"},{"id":"skill-git-switch-branches","courseId":"git","unitId":"git-branches","title":"Move between branches with switch"},{"id":"skill-git-explain-head","courseId":"git","unitId":"git-branches","title":"Say what HEAD points at, attached or detached"},{"id":"skill-git-compare-histories","courseId":"git","unitId":"git-branches","title":"Tell fast-forward from divergent history"},{"id":"skill-git-merge-branches","courseId":"git","unitId":"git-merging","title":"Merge a branch and read the result"},{"id":"skill-git-read-conflicts","courseId":"git","unitId":"git-merging","title":"Read conflict markers and finish the merge"},{"id":"skill-git-rebase-commits","courseId":"git","unitId":"git-merging","title":"Rebase, and see what it rewrites"},{"id":"skill-git-choose-integration","courseId":"git","unitId":"git-merging","title":"Choose merge or rebase for the job"},{"id":"skill-git-clone-and-fetch","courseId":"git","unitId":"git-remotes","title":"Clone a repository and fetch from origin"},{"id":"skill-git-track-branches","courseId":"git","unitId":"git-remotes","title":"Read a tracking branch, ahead and behind"},{"id":"skill-git-pull-and-push","courseId":"git","unitId":"git-remotes","title":"Pull as fetch plus merge, then push"},{"id":"skill-git-weigh-force-push","courseId":"git","unitId":"git-remotes","title":"Weigh a force push, and use a pull request"},{"id":"skill-git-restore-files","courseId":"git","unitId":"git-recovery","title":"Throw away changes with git restore"},{"id":"skill-git-choose-undo","courseId":"git","unitId":"git-recovery","title":"Choose between revert and the three resets"},{"id":"skill-git-amend-and-stash","courseId":"git","unitId":"git-recovery","title":"Amend the last commit and stash work in progress"},{"id":"skill-git-use-reflog","courseId":"git","unitId":"git-recovery","title":"Find lost commits with the reflog"},{"id":"skill-devops-tell-image-from-container","courseId":"devops","unitId":"devops-containers","title":"Tell an image from a container, and both from a VM"},{"id":"skill-devops-read-a-dockerfile","courseId":"devops","unitId":"devops-containers","title":"Read a Dockerfile line by line"},{"id":"skill-devops-order-layers-for-cache","courseId":"devops","unitId":"devops-containers","title":"Order layers so the cache survives"},{"id":"skill-devops-run-a-container","courseId":"devops","unitId":"devops-containers","title":"Publish a port and keep data past the container"},{"id":"skill-devops-trace-a-pipeline","courseId":"devops","unitId":"devops-pipelines","title":"Say what a pipeline runs, and when"},{"id":"skill-devops-order-stages-and-gates","courseId":"devops","unitId":"devops-pipelines","title":"Order stages and make a gate mean something"},{"id":"skill-devops-build-once-and-promote","courseId":"devops","unitId":"devops-pipelines","title":"Build once and promote the same artifact"},{"id":"skill-devops-handle-ci-secrets","courseId":"devops","unitId":"devops-pipelines","title":"Give a job a secret without printing it"},{"id":"skill-devops-read-env-vars","courseId":"devops","unitId":"devops-config","title":"Read configuration from environment variables"},{"id":"skill-devops-configure-per-environment","courseId":"devops","unitId":"devops-config","title":"Vary configuration per environment, not per build"},{"id":"skill-devops-apply-twelve-factor","courseId":"devops","unitId":"devops-config","title":"Keep config out of the code and the image"},{"id":"skill-devops-rotate-a-secret","courseId":"devops","unitId":"devops-config","title":"Contain and rotate a leaked secret"},{"id":"skill-devops-choose-a-rollout","courseId":"devops","unitId":"devops-deploy","title":"Choose a rollout and name what it costs"},{"id":"skill-devops-wire-health-checks","courseId":"devops","unitId":"devops-deploy","title":"Tell liveness from readiness"},{"id":"skill-devops-plan-a-rollback","courseId":"devops","unitId":"devops-deploy","title":"Plan the rollback before the deploy"},{"id":"skill-devops-sequence-migrations","courseId":"devops","unitId":"devops-deploy","title":"Sequence a migration around a deploy"},{"id":"skill-devops-choose-a-signal","courseId":"devops","unitId":"devops-observability","title":"Pick the signal that answers the question"},{"id":"skill-devops-control-cardinality","courseId":"devops","unitId":"devops-observability","title":"Keep a metric label from exploding"},{"id":"skill-devops-read-percentiles","courseId":"devops","unitId":"devops-observability","title":"Read a percentile instead of an average"},{"id":"skill-devops-alert-on-symptoms","courseId":"devops","unitId":"devops-observability","title":"Alert on symptoms and hold an SLO"},{"id":"skill-devops-choose-compute","courseId":"devops","unitId":"devops-cloud","title":"Choose between a VM, a container and a function"},{"id":"skill-devops-choose-managed-or-self-run","courseId":"devops","unitId":"devops-cloud","title":"Decide what to run yourself"},{"id":"skill-devops-place-across-zones","courseId":"devops","unitId":"devops-cloud","title":"Place a system across zones and regions"},{"id":"skill-devops-read-a-cloud-bill","courseId":"devops","unitId":"devops-cloud","title":"Say what actually drives the bill"},{"id":"skill-security-spot-untrusted-input","courseId":"security","unitId":"security-injection","title":"Find where input stops being data and becomes code"},{"id":"skill-security-parameterise-queries","courseId":"security","unitId":"security-injection","title":"Close a SQL injection with parameters"},{"id":"skill-security-avoid-command-injection","courseId":"security","unitId":"security-injection","title":"Run a command without handing input to a shell"},{"id":"skill-security-block-path-traversal","courseId":"security","unitId":"security-injection","title":"Keep a file path inside the directory it belongs to"},{"id":"skill-security-store-passwords","courseId":"security","unitId":"security-authn","title":"Store a password you can never read back"},{"id":"skill-security-salt-and-slow-hashes","courseId":"security","unitId":"security-authn","title":"Salt the password and slow the hash down"},{"id":"skill-security-issue-session-tokens","courseId":"security","unitId":"security-authn","title":"Issue, carry and expire a session token"},{"id":"skill-security-defend-the-login","courseId":"security","unitId":"security-authn","title":"Defend a login from stuffing, enumeration and timing"},{"id":"skill-security-separate-authn-from-authz","courseId":"security","unitId":"security-authz","title":"Tell authentication from authorization"},{"id":"skill-security-check-object-ownership","courseId":"security","unitId":"security-authz","title":"Check who owns the object, not just who is calling"},{"id":"skill-security-contain-privilege","courseId":"security","unitId":"security-authz","title":"Stop a user from granting themselves more"},{"id":"skill-security-deny-by-default","courseId":"security","unitId":"security-authz","title":"Deny by default and allow on purpose"},{"id":"skill-security-recognise-xss","courseId":"security","unitId":"security-web","title":"Tell stored, reflected and DOM XSS apart"},{"id":"skill-security-escape-for-the-context","courseId":"security","unitId":"security-web","title":"Escape for the context the value lands in"},{"id":"skill-security-stop-csrf","courseId":"security","unitId":"security-web","title":"Stop a forged cross-site request"},{"id":"skill-security-set-response-headers","courseId":"security","unitId":"security-web","title":"Set the response headers that carry their weight"},{"id":"skill-security-handle-secrets","courseId":"security","unitId":"security-secrets","title":"Keep a secret in a store and rotate it when it leaks"},{"id":"skill-security-tell-hashing-from-encryption","courseId":"security","unitId":"security-secrets","title":"Tell hashing from encryption from encoding"},{"id":"skill-security-reason-about-tls","courseId":"security","unitId":"security-secrets","title":"Say what TLS promises and what it does not"},{"id":"skill-security-use-safe-randomness","courseId":"security","unitId":"security-secrets","title":"Use randomness an attacker cannot predict"},{"id":"skill-security-read-a-dependency-tree","courseId":"security","unitId":"security-supplychain","title":"Follow a vulnerability through a dependency tree"},{"id":"skill-security-triage-advisories","courseId":"security","unitId":"security-supplychain","title":"Triage an advisory against your own code"},{"id":"skill-security-lock-dependencies","courseId":"security","unitId":"security-supplychain","title":"Lock and verify what you install"},{"id":"skill-security-limit-ci-privilege","courseId":"security","unitId":"security-supplychain","title":"Give a build only the access it needs"},{"id":"skill-testing-arrange-act-assert","courseId":"testing","unitId":"testing-first","title":"Structure a test as arrange, act, assert"},{"id":"skill-testing-write-assertions","courseId":"testing","unitId":"testing-first","title":"Write an assertion that can fail"},{"id":"skill-testing-test-behaviour","courseId":"testing","unitId":"testing-first","title":"Test behaviour, not implementation"},{"id":"skill-testing-write-first-test","courseId":"testing","unitId":"testing-first","title":"Write the first test for a function"},{"id":"skill-testing-cover-boundaries","courseId":"testing","unitId":"testing-cases","title":"Test boundaries and off-by-one"},{"id":"skill-testing-test-edge-inputs","courseId":"testing","unitId":"testing-cases","title":"Test empty and single-element inputs"},{"id":"skill-testing-choose-equivalence-classes","courseId":"testing","unitId":"testing-cases","title":"Pick one case per equivalence class"},{"id":"skill-testing-test-error-paths","courseId":"testing","unitId":"testing-cases","title":"Test the error path"},{"id":"skill-testing-choose-test-doubles","courseId":"testing","unitId":"testing-doubles","title":"Choose a stub, a mock or a fake"},{"id":"skill-testing-inject-dependencies","courseId":"testing","unitId":"testing-doubles","title":"Inject dependencies to make code testable"},{"id":"skill-testing-avoid-mocking-others","courseId":"testing","unitId":"testing-doubles","title":"Avoid mocking what you do not own"},{"id":"skill-testing-control-time","courseId":"testing","unitId":"testing-doubles","title":"Control time and randomness in tests"},{"id":"skill-testing-shape-test-pyramid","courseId":"testing","unitId":"testing-suites","title":"Shape a suite with the test pyramid"},{"id":"skill-testing-name-tests","courseId":"testing","unitId":"testing-suites","title":"Name a test so a failure explains itself"},{"id":"skill-testing-isolate-shared-state","courseId":"testing","unitId":"testing-suites","title":"Isolate tests from shared state"},{"id":"skill-testing-remove-flakiness","courseId":"testing","unitId":"testing-suites","title":"Find the real cause of a flaky test"},{"id":"skill-testing-refactor-under-green","courseId":"testing","unitId":"testing-refactor","title":"Refactor under a green suite"},{"id":"skill-testing-write-characterisation-tests","courseId":"testing","unitId":"testing-refactor","title":"Pin unknown code with characterisation tests"},{"id":"skill-testing-take-small-steps","courseId":"testing","unitId":"testing-refactor","title":"Change code in small, reversible steps"},{"id":"skill-testing-spot-code-smells","courseId":"testing","unitId":"testing-refactor","title":"Spot the code smells worth acting on"},{"id":"skill-testing-shape-pull-requests","courseId":"testing","unitId":"testing-review","title":"Shape a pull request others can review"},{"id":"skill-testing-review-for-design","courseId":"testing","unitId":"testing-review","title":"Review for design, not style"},{"id":"skill-testing-write-useful-comments","courseId":"testing","unitId":"testing-review","title":"Write comments that earn their place"},{"id":"skill-testing-name-and-prune-code","courseId":"testing","unitId":"testing-review","title":"Name well and delete what is dead"}]}