You already pay for Claude or Cursor. Capstok is the textbook that fits — 7,500+ challenges, three labelled prompts per task, the whole catalogue reachable via MCP. Less than a coffee a week for the all-access membership, or buy just the course you care about.
Cancel anytime · completed courses and certificates stay with you · prices in USD based on your region.
How a 3D printer works, what to print first, and how to calibrate it for clean prints — independent of brand.
Stop downloading; start designing. Parametric CAD from first principles to your first custom parts.
7-day refund window. If you purchase any plan and aren't satisfied, email support@capstok.com within 7 days of purchase for a full refund — no questions asked.
Completed courses stay with you. Whether you cancel or your plan expires, every course you finished and every certificate you earned remain permanently on your account. Access to incomplete content stops when the plan ends.
No auto-renewal surprise. All current plans are one-time access grants (not subscriptions). You won't be charged again automatically.
Multi-body assemblies, surface modeling, multi-material, functional parts, post-processing — everything past first-principles CAD.
Ten real projects walked end-to-end: measure → model → slice → print → refine → use.
Engineer the context window as a budgeted resource: select, order, compress, cache, and measure what the model sees. The discipline underneath every reliable RAG, agent, and long-session assistant.
Every level of RAG — from naive cosine-on-embeddings to hybrid + reranking + multi-hop + agentic + production DevOps. Each module is the next move when the previous one breaks.
Context engineering for agentic, multi-turn, multi-agent, and adversarial systems at scale: multi-agent context, dynamic assembly, hierarchical memory, KV-cache-aware design, tool-loop management, long-horizon memory, security, multi-modal, and a context platform.
End-to-end: tools, memory, planning, guardrails, evals, observability, cost, safety, shipping. Build an agent that survives real users.
From your first user to your millionth. Cost, latency, observability, queues, multi-model, vector DBs, on-call, deploys, compliance — at every scale milestone.
Ten end-to-end AI projects. Each module is a full build with scope, code, eval, and deployment. Hybrid RAG, multi-modal, text-to-SQL, eval gen, semantic cache, doc extraction, orchestration, browser agent, voice, fine-tuning.
How LLM serving actually works: the autoregressive forward pass, the KV cache, memory-vs-compute bounds, PagedAttention, continuous batching, and streaming — then vLLM internals, the serving-framework landscape, inference optimization, and capacity planning. Learn to serve LLMs fast and cheaply to an SLO.
Serve a real fleet of models the way companies actually do it: NVIDIA Triton, TensorRT-LLM, and NIM, plus graph compilation, ensembles/BLS, multi-model GPU sharing, observability, and production deployment.
Run ML and LLM systems in production the way it's actually done: experiment tracking, model/prompt registries with lineage, CI/CD with eval gates, safe deployment patterns, automated LLM evals, observability, guardrails, and a continuous improvement loop. The discipline that turns a working demo into a system you can trust at scale.
100 challenges to understand blockchains from the inside out. Build a toy chain, mint a wallet, send your first real transaction.
Stop writing Solana programs like they're Solidity contracts. 100 challenges to build the Anchor mental model from the account layer up.
Ethereum smart contract development with Foundry — from first deploy to auditable DeFi.
Build DeFi on Ethereum end-to-end — AMMs, lending, stables, oracles, derivatives, vaults, restaking. Method-first, ships protocol-grade code.
Build DeFi on Solana — Phoenix order books, Drift perps, Jupiter aggregation, MarginFi lending, Pyth oracles, liquid staking.
Dissect the EVM, mempool, MEV layer, beacon chain, and L2 stack — work at the protocol layer, not just the contract layer.
Dissect the Solana runtime, Sealevel, JITO/MEV, Geyser, compression, and SVM forks — operate at the protocol layer.
From UTXOs to Taproot, Lightning, Ordinals, and BitVM — Bitcoin at the protocol layer and at the application layer.
100 challenges to build the ZK mental model from sigma protocols up to zkVMs — Python and Rust throughout, no hand-waving.
Build first-iteration toys of the protocols that shaped Ethereum and Solana — Optimism, zkRollups, ZCash/Tornado privacy pools, EigenLayer, ERC-4337 on the EVM side; Phoenix CLOB, Bubblegum compression, Token-2022 confidential transfer, Wormhole bridges on the Solana side.
100 challenges on the production ZK circuit language. Compile, constrain, prove, and ship — from multiplier.circom to zk-identity.
100 short challenges to turn you from someone who asks AI for answers into someone who builds with it.
For product builders integrating AI into an existing app: spot the opportunities worth building, ship AI features end to end, get the UX, cost, and trust right, and measure what works.
From a one-sentence idea to a publishable 3-minute short — prompts, tools, and craft.
100 challenges for the filmmaker who already knows Runway. Narrative discipline, character consistency, lip sync, editorial, VFX hybrid pipelines, and how to actually ship.
100 challenges for the filmmaker who wants to get paid. Briefs, hooks, platform-native delivery, hero moments, documentary ethics, VO direction, performance measurement, and how to sell the work.
Compute, storage, IAM, monitoring, networking, cost, and governance — the core building blocks of AWS, Azure, GCP, and DigitalOcean for builders new to multi-cloud.
VPCs, load balancing, firewalls, VPNs, DNS, TLS, API gateways, observability, and zero-trust — the full network stack across AWS, Azure, GCP, and DigitalOcean.
From your first `docker run` to running a multi-cloud k8s platform with GitOps, autoscaling, observability, and chaos engineering — the full container journey.
Schedule, partition, autoscale, and operate NVIDIA GPUs on Kubernetes for AI workloads. From the device plugin to MIG, gang scheduling, and on-call runbooks.
Bench gear, Ohm's law, components, schematics, transistors, op-amps, digital basics, sensors, communication buses, and your first real project.
100 challenges to take you from `python --version` to shipping a FastAPI + Celery service with full observability — and the canonical 2026 RAG pipeline as the capstone.
100 challenges to take you from `node --version` to shipping a multi-tenant Fastify + BullMQ + Prisma service with pino, OTel, and a Docker image you'd put on production.
100 challenges to take you from `go version` to shipping a production Go service with OTel, structured logs, graceful shutdown, and a Docker image small enough to fit in a tweet.
100 challenges to take you from `cargo new` to shipping an async Rust service with axum, sqlx, tracing, and a webhook delivery worker that fights real network failures.
Deep internals, concurrent features, React Server Components, advanced patterns, and production-grade state management — everything you need to build React applications that are fast, correct, and maintainable at scale.
Build React applications that feel instant by updating the UI before the server responds — with correct rollback, conflict resolution, and offline support.
100 challenges — from your first MongoDB insert to reading WAL files, tuning autovacuum, and orchestrating a zero-downtime schema migration on a 100M-row table.
Ship a real money-moving product — payments, ledgers, compliance, payouts, BaaS, custodianship. Engineering, regulatory, and ops literacy fused.
100 challenges — from reading a curl waterfall to finding the index that makes your p99 drop from 4s to 40ms.
100 challenges from CQRS and CDC through Kafka, distributed transactions, time-series, object storage, streaming video, multi-region deployments, Lambda/Kappa architectures, and database internals deep cuts.
A server that works for 10 users breaks at 10,000. Rate limiting, caching, load balancing, queues — one module at a time.
100 challenges, from race conditions on your laptop to consensus across continents.
Three parties, one answer, zero inputs revealed. Build real MPC from shares and OTs up to threshold ECDSA wallets and sealed-bid auctions — 100 challenges in Python and Rust.
A practical, milestone-driven playbook: what breaks at each step (100 → 1k → 10k → 100k users) and what to add — not in primitives, in moves.
The mental model and minimum vocabulary for every later course in the track — what IoT actually is, what a microcontroller really does, and how connected products are architected from first principles.
From a single neuron to a deployed, monitored ML service. 100 challenges covering the full supervised learning lifecycle.
Bridge from advanced ML to transformer-based AI systems. Embeddings, RAG, agents, eval, and production AI APIs — 100 challenges.
Fine-tuning, quantization, and production deployment of large language models. For engineers who want to go beyond API calls.
100 challenges, from a scalar gradient to a fine-tuned model streaming behind your own API.
Hands-on, single-GPU fine-tuning: adapt an open model to your task with LoRA/QLoRA, evaluate it honestly against the base, then quantize and self-host it behind your own OpenAI-compatible API. Free-tier and Colab friendly throughout.
The mental models behind compounding user growth — loops, funnels, metrics, and experimentation.
The craft of words that convert — from hero headlines to long-form sales pages.
How to occupy a specific, defensible position in a buyer's mind — and write the words that hold it.
Search as a compounding distribution channel — from keyword mechanics to content architecture.
Turn signups into activated users and activated users into paying customers through sequences, segments, and automation.
The math and mechanics of ads — CAC/LTV, bidding strategy, creative, and scaling without burning budget.
Measure what matters — from cohort analysis to attribution models to decisions under partial data.
Launch playbooks, ICP definition, competitive intelligence, and sales enablement — the connective tissue between product and market.
Marketing in a world where agents — not browsers — are the discovery layer.
How brands compound over time — voice, visual identity, positioning, and the long game of being the name people reach for first.
Platform mechanics, audience compounding, and community flywheels — from zero followers to a distribution moat.
Narrative control, press outreach, thought leadership, and the mechanics of getting coverage that compounds.
The discipline of getting more from what you have — landing pages, flows, pricing pages, and checkout — through structured testing and UX psychology.
The math of strategic interaction, from Prisoner's Dilemma to mechanism design. Ten modules, a hundred worked problems, one capstone.
From sample spaces and random variables through the Central Limit Theorem, statistical inference, and Bayesian reasoning — the mathematical toolkit every quantitative builder needs.
From divisibility and modular arithmetic through primes, quadratic residues, elliptic curves, and computational algorithms — the number theory that powers RSA, DH, and modern cryptosystems.
From Caesar ciphers and Shannon entropy through symmetric encryption, public-key cryptography, digital signatures, zero-knowledge proofs, authenticated encryption, and a preview of homomorphic encryption.
Shor's algorithm, NIST post-quantum standards, lattice theory, LWE, CRYSTALS-Kyber, CRYSTALS-Dilithium, hash-based signatures, code-based cryptography, and isogeny-based cryptography.
The mathematical foundations of zero-knowledge proofs: interactive proof systems, Sigma protocols, Fiat-Shamir, polynomial commitments, R1CS, QAPs, Groth16, PLONK, and STARKs.
From Gentry's blueprint through Ring-LWE, BFV, BGV, CKKS, TFHE, bootstrapping, and practical FHE applications — the mathematics and engineering of computing on ciphertexts.
Cohen's hardware-product playbook — translated for any builder shipping a real product. Hardware-first with software-PM analogues woven in.
The craft, end to end — discovery to launch to iteration. Frameworks you'll actually use.
From tester to QA engineer: SDLC, test lifecycle, bug reports, DevTools, API testing, and smoke testing — 100 challenges to build your foundation.
Playwright, pytest, Page Object Model, AI test generation, visual regression, and CI gates — 100 challenges to build a production automation suite.
Unit testing, integration testing, mocking, coverage, testable code design, CI/CD, system design, and AI — 100 challenges to become a Software Development Engineer in Test.
Threat modeling, AuthN/AuthZ, injection, XSS, CSRF/SSRF, TLS/headers, crypto pitfalls, modern web threats, detection + IR. Defender-first, anchored in OWASP, MITRE ATT&CK, and real CVEs.
Linux + Windows + cloud hardening, network defence, memory corruption, kernel sandboxing, K8s security, SIEM + detection engineering. From host config to SOC ops.
Mobile (iOS + Android), hardware roots of trust, IoT (BLE/WiFi/Matter), firmware analysis, anti-tampering, DRM, fleet OTA. From threat model to production OTA.
Authorized penetration testing: methodology, recon, scanning, web + network + AD + cloud pentesting, phishing, reporting, continuous pentest programs.
Smart contract security from threat model to audit report. Every task: REPRODUCE the bug → PATCH the contract → VERIFY with a Foundry invariant.
Security as a product feature for fintechs. Threat modeling, KYC/AML, payments, customer data, banking operations, vendors, security engineering, compliance, audits — with explicit **Recommendation** + **Try to hack** sections in every task.
Build a pentest machine from Pi/Arduino/ESP32, master Flipper/Proxmark/HackRF/JTAG, learn 0-day research + responsible disclosure, and graduate CTF mastery — culminating in red-team field operations.