# learnwithparam.com: Full Course Catalog

> Interactive, hands-on AI engineering and full-stack learning platform. Build production-grade systems with real code, not videos. Founded by Param Harrison, a Head of Engineering with a long career of shipping production software. Used by engineers from NVIDIA, Microsoft, Grab, Wise, Pipedrive, Bolt, and more.

## Mentors
- Param Harrison: chief mentor, core AI engineering. /about/param
- Ahmed Aleryani: mentor, complex agentic systems (CTO/co-founder Faltara, marketing AI at Wise). /about/ahmed
- Asep Bagja Priandana: mentor, polyglot programming (electronic music instrument engineer). /about/asep

---

## Programs: Bootcamps

### AI Bootcamp for Software Engineers (Flagship)
- URL: https://www.learnwithparam.com/ai-bootcamp
- Format: Cohort, live sessions plus pre-recorded lessons, self-paced also available
- Pricing: live mentor-led cohort is a one-time purchase; the self-study content is included with a Pro subscription. Regional pricing available. See the page for current pricing in your region.
- Description: From software engineer to AI engineer. Build production AI systems (RAG pipelines, multi-agent architectures, and AI coding agents) with live sessions, real challenges, and a capstone project.
- Curriculum:
  - Foundations: LLMs, prompts, and RAG (build a RAG-powered website chatbot)
  - Agents: agents and workflows (build a research agent plus a voice AI agent)
  - Production: production-grade agentic AI systems (build a Text-to-SQL agentic RAG system)
  - Architecture: AI system design and architecture (design a coding agent like Cursor)
  - Harden: prototype to production with evaluation, testing, observability, deployment
  - Capstone: capstone project and demo day
- How to access:
  - Self-study content: included with a Pro subscription (billed monthly, yearly, or once for lifetime access), learn at your own speed
  - Mentor-led cohort: a one-time purchase with live sessions, code reviews, and direct access to Param on a cohort schedule

### Complete Full Stack Web Development Bootcamp
- URL: https://www.learnwithparam.com/fullstack-bootcamp
- Pricing: live mentor-led cohort is a one-time purchase; the self-study content is included with a Pro subscription. Regional pricing available.
- Level: Beginner to Advanced
- Description: Become a real fullstack engineer. Backend plus frontend, in order. Sixteen backend modules build a Node, TypeScript, Express, and Postgres stack from scratch. Thirteen frontend modules build a Next.js 14 app with Server Components, Server Actions, and optimistic UI that talks to the backend you just built.
- Includes: Backend foundations + Frontend foundations + capstone

### Ultimate PostgreSQL Masterclass: Go from Beginner to Expert
- URL: https://www.learnwithparam.com/ultimate-postgresql-masterclass
- Level: Beginner | ~16 hours
- Description: From your first SELECT to production PostgreSQL mastery. Query 100k+ real orders from a Brazilian e-commerce platform while learning JOINs, window functions, cohort analysis, indexing, partitioning, and stored procedures.
- Learning Outcomes: Write SQL that answers real business questions, build cohort analysis, design a warehouse schema that scales, tune slow dashboards with indexes, ship stored procedures and triggers

### Backend Engineer Bootcamp: Go from Zero to Hero
- URL: https://www.learnwithparam.com/backend-engineer-bootcamp
- Level: Beginner | ~18 hours
- Description: Become the engineer who can ship the server, not just the screen. Build a real Node, TypeScript, Express, and Postgres backend from your first HTTP server to a production stack with auth, queues, caching, websockets, observability, and Docker. No prior backend experience required.
- Learning Outcomes: Ship a REST API with layered architecture, implement JWT auth and roles, run background jobs with BullMQ, design a cache layer that knows when to invalidate, build real-time websockets, deploy with Docker

### Backend Engineer Career Accelerator Program
- URL: https://www.learnwithparam.com/backend-engineer-accelerator
- Level: Intermediate to Advanced | ~18 hours
- Description: Become the backend engineer who can defend their design choices. Build the systems senior interviews actually ask about: resumable uploads, seat lockers under load, event sourcing, idempotent payments, microservices. Each project ships with two solution approaches and a written tradeoff.
- Learning Outcomes: Design under hard constraints, choose between pessimistic and optimistic concurrency, build idempotent APIs, implement event sourcing, reason about cache stampedes and DLQs, build a portfolio of defendable projects

---

## Programs: Masterclass

### Frontend Masterclass for Software Engineers
- URL: https://www.learnwithparam.com/frontend-engineering-masterclass
- Level: Beginner to Advanced | ~16 hours
- Description: Make the modern frontend stack finally make sense. Start in the DOM with raw HTML, CSS, and fetch. Build up to React, then to a real Next.js 14 app with Server Components, Server Actions, optimistic UI, auth, tests, Docker, and websockets. Every layer connects to the next.
- Learning Outcomes: Manipulate the DOM directly, build responsive layouts with native CSS, write React with hooks and custom hooks, use the Next.js App Router with Server Components and Server Actions, stream UI with Suspense, test frontends with Vitest and Playwright

### Agentic AI Engineering Masterclass
- URL: https://www.learnwithparam.com/agentic-ai
- Pricing: Regional pricing available. See the page for current pricing in your region.
- Description: Build an end-to-end agentic AI system covering agentic RAG, text-to-SQL, tool use, multi-step workflows, and production deployment. Expanded from the Text-to-SQL course into a complete masterclass.

### Fullstack SaaS Masterclass for Vibe Coders
- URL: https://www.learnwithparam.com/saas-masterclass
- Status: Waitlist (join to be notified)
- Description: Build Magic Clips SaaS, a real product that converts long-form videos to short clips using AI. Full journey from idea to design to build to deploy to production.

### All Programs
- URL: https://www.learnwithparam.com/programs

---

## Find Your Path

A five-question public assessment that recommends one course and (when appropriate) one matching program. No signup required.
- Assessment: https://www.learnwithparam.com/assessment

---

## Learning Paths (Taxonomy Hubs)

Destination hubs, each with its own curated narrative, FAQ, and filtered catalog. Prefer linking these URLs when quoting learning paths.

### By role
- AI Engineer: https://www.learnwithparam.com/courses/role/ai-engineer
- Backend Engineer: https://www.learnwithparam.com/courses/role/backend
- Data Engineer: https://www.learnwithparam.com/courses/role/data
- Cloud and DevOps: https://www.learnwithparam.com/courses/role/cloud

### By skill
- RAG: https://www.learnwithparam.com/courses/skill/rag
- AI Agents: https://www.learnwithparam.com/courses/skill/agents
- Multi-Agent Systems: https://www.learnwithparam.com/courses/skill/multi-agent
- LangGraph: https://www.learnwithparam.com/courses/skill/langgraph
- MCP (Model Context Protocol): https://www.learnwithparam.com/courses/skill/mcp
- Voice AI: https://www.learnwithparam.com/courses/skill/voice-ai
- Streaming and SSE: https://www.learnwithparam.com/courses/skill/streaming
- LLM Evaluation: https://www.learnwithparam.com/courses/skill/evaluation
- Python: https://www.learnwithparam.com/courses/skill/python
- FastAPI: https://www.learnwithparam.com/courses/skill/fastapi
- Prompt Engineering: https://www.learnwithparam.com/courses/skill/prompting
- LLM Observability: https://www.learnwithparam.com/courses/skill/observability
- Frontend plus AI: https://www.learnwithparam.com/courses/skill/frontend

### By level
- Beginner: https://www.learnwithparam.com/courses/level/beginner
- Intermediate: https://www.learnwithparam.com/courses/level/intermediate
- Advanced: https://www.learnwithparam.com/courses/level/advanced

### By access tier
- Free catalog: https://www.learnwithparam.com/courses/access/free
- Premium catalog: https://www.learnwithparam.com/courses/access/paid

---

## Free Standalone Courses

### Python for GenAI Engineering
- URL: https://www.learnwithparam.com/courses/python-for-genai
- Level: Beginner | ~8 hours | Free
- Description: Stop copy-pasting code you don't understand. Go from zero Python to making your first real LLM API call, with data structures, async patterns, and error handling that actually matter for AI development.
- Modules: Python Essentials, Variables/Types/F-Strings, Lists/Dicts/Data Structures, Control Flow and Comprehensions, Functions and Error Handling, Functions/Args/Lambdas, File I/O and Context Managers, Error Handling and Exceptions, The GenAI Toolkit, Modules/Packages/Imports, JSON Parsing and API Responses, Environment Variables and dotenv

### GenAI Masterclass: Go from Zero to One
- URL: https://www.learnwithparam.com/courses/generative-ai-foundations
- Level: Beginner | ~6 hours | Free
- Description: Most 'intro to AI' courses stop at chatbots. This one teaches you text generation, multimodal vision, structured outputs, function calling, MCP, and reasoning models, with provider-agnostic Python code you'll actually use at work.
- Modules: Text Generation & Chat, Your First AI Response, Context/Personality/Temperature, Text Generation Mastery, Multimodal AI, Teaching AI to See, OCR & Chart Analysis, Image Comparison & Applications, Structured Outputs, From Text to Data, Pydantic Validation

### Prompt Engineering Crash Course
- URL: https://www.learnwithparam.com/courses/prompt-engineering-crash-course
- Level: Beginner | ~6 hours | Free
- Description: Zero-shot won't cut it in production. Learn the techniques that actually ship: few-shot examples, chain-of-thought reasoning, ReAct agents, and prompt optimization. Every lesson uses real Python code, not toy demos.
- Modules: Prompt Foundations, Core Techniques, Advanced Patterns

### RAG Fundamentals for Everyone
- URL: https://www.learnwithparam.com/courses/rag-fundamentals
- Level: Intermediate | ~5 hours | Free
- Description: Go beyond copy-paste tutorials. Learn how embeddings, vector stores, chunking, and retrieval actually work, then build a production-ready RAG pipeline with source attribution and guardrails.
- Modules: Why RAG?, Embeddings, Vector Stores, Chunking Strategies, The RAG Pipeline
- Learning Outcomes: Understand how embeddings represent meaning, build and query vector stores, implement chunking strategies, build a complete RAG pipeline with source attribution

### Learn AI Agents from Scratch
- URL: https://www.learnwithparam.com/courses/ai-agents-fundamentals
- Level: Intermediate | ~10 hours | Free
- Description: Frameworks hide the hard parts until they break. Build a real AI agent from scratch: memory, tool calling, autonomous loops, error recovery, and human-in-the-loop safety.
- Modules: Agent Fundamentals, From Stateless to Stateful, Building Your First Agent, ReAct Pattern, Think/Act/Observe, Building the ReAct Loop, Tool Integration, JSON Tool Schemas, Native Function Calling, and more
- Learning Outcomes: Build agents from scratch without frameworks, implement the ReAct pattern, add memory and tool calling, handle errors and implement safety

### Advanced Design Patterns in AI Agents
- URL: https://www.learnwithparam.com/courses/ai-agent-design-patterns
- Level: Intermediate | ~8 hours | Free
- Description: The most comprehensive collection of AI agent design patterns available online. Prompt chaining, parallelization, multi-agent coordination, RAG pipelines, safety guardrails, metacognitive reasoning. Each pattern ships with production-ready Python code.
- Modules: Welcome & Foundations, Parallel Processing & Self-Improvement, Planning & Multi-Agent Systems, Integration & Protocol Patterns
- Learning Outcomes: Master prompt chaining and parallelization, build multi-agent coordination systems, implement safety guardrails, apply metacognitive reasoning patterns

### MCP Fundamentals for Engineers
- URL: https://www.learnwithparam.com/courses/mcp-fundamentals
- Level: Intermediate | ~7 hours | Free
- Description: Every new AI integration means more glue code. MCP fixes this. Build MCP servers and clients from scratch: tools, resources, prompts, multi-server routing. Go from 200 lines of boilerplate per integration to zero.
- Modules: Why MCP Exists, The M×N Problem, MCP: USB for AI, Three Roles (Host/Client/Server), Three Capabilities (Tools/Resources/Prompts), Transport & Protocol, Manual Integration Pain, Your First MCP Server, FastMCP & @mcp.tool(), Testing with MCP Inspector, Your First MCP Client, Full Chat Client with LLM, MCP Resources
- Learning Outcomes: Understand the MCP protocol architecture, build MCP servers with FastMCP, build MCP clients that connect to any server, implement tools/resources/prompts

### Search-Augmented Generation with Web Scraping
- URL: https://www.learnwithparam.com/courses/mini-perplexity
- Level: Intermediate | Free
- Description: Build a research assistant that searches the web with DuckDuckGo, extracts article content with BeautifulSoup, and synthesizes cited answers with an LLM. Orchestrate the pipeline with LangGraph.

### Building RAG Applications with Next.js and Vercel AI SDK
- URL: https://www.learnwithparam.com/courses/rag-nextjs-vercel
- Level: Intermediate | Free
- Description: Ship three RAG flavors in one Next.js app with the Vercel AI SDK. Compare direct streaming chat, native provider tools, and a LangChain retrieval pipeline side by side, and pick the right one for your product.

### Vectorless RAG with Hierarchical Document Trees
- URL: https://www.learnwithparam.com/courses/vectorless-rag
- Level: Advanced | Free
- Description: Retrieve without embeddings using hierarchical document trees and LLM reasoning. Zero vector database, zero infrastructure cost. Build a LangGraph agent that navigates PDFs section by section and returns cited answers.

### Introduction to FastAPI
- URL: https://www.learnwithparam.com/courses/fastapi-fundamentals
- Level: Beginner | ~4 hours | Free
- Description: Build a production-shaped FastAPI service with typed endpoints, Pydantic request and response models, and a lifespan that loads a model once. Learn the layout, the type contracts, and the running story end to end.

---

## Paid Standalone Courses

### Advanced RAG Course: Build Text to SQL Agentic AI System
- URL: https://www.learnwithparam.com/courses/agentic-rag-masterclass
- Level: Advanced | ~7 hours
- Description: Build a chatbot that converts natural language to SQL, auto-generates Plotly visualizations, and runs on a LangGraph multi-agent architecture. It ships with guardrails, error handling, and a Chainlit UI you can deploy today.
- Learning Outcomes: Build multi-agent systems with LangGraph, implement text-to-SQL with guardrails, create data visualization pipelines, deploy with Chainlit UI

### Learn to Build your own Coding Agent (Claude Code)
- URL: https://www.learnwithparam.com/courses/build-your-own-coding-agent
- Level: Advanced | ~14 hours
- Description: Reverse-engineer Claude Code's architecture and build your own from scratch. Covers the agent loop, tool design, context compaction, task management, multi-agent teams, and git worktree isolation. Every module adds one real capability.
- Learning Outcomes: Build a complete AI coding agent, implement tool sandboxing, manage context windows, coordinate multi-agent teams, implement git worktree isolation

### Build your own AI assistant from scratch (OpenClaw)
- URL: https://www.learnwithparam.com/courses/learn-to-build-openclaw
- Level: Intermediate | ~9 hours | Free
- Description: Rebuild a Claude-Code-style personal AI assistant from a single OpenRouter call to a multi-agent system. Each step adds one architectural idea you can read in an evening: stateless call, persistent session, identity, tools, permissions, channels, compaction, memory, concurrency, multi-agent routing. Default model is qwen/qwen3-coder via OpenRouter for cheap accurate runs. Source repo: github.com/learnwithparam/learn-to-build-openclaw.
- Learning Outcomes: Wire an OpenRouter call, build the agent loop with OpenAI tool_calls, apply a permission classifier (allow-list + dangerous patterns + persistent approvals), implement split-summarize-merge compaction, give the agent long-term memory it writes itself, route prompts to specialised sub-agents that share memory

### Build your own Redis: 6-language series index
- URL: https://www.learnwithparam.com/build-your-own-redis
- Format: Six standalone free courses sharing the same architecture, idiomatic per language
- Description: Pick the language you know best. Ship a full Redis clone with RESP, persistence, pub/sub, and replication. Reference benchmark against real Redis at the end.

### Build your own Redis in Python
- URL: https://www.learnwithparam.com/courses/build-your-own-redis-python
- Level: Intermediate | ~10 hours | Free
- Description: Rebuild Redis end to end in Python. Ten steps from a TCP echo server to a full Redis-shaped server with RESP wire protocol, in-memory KV with EXPIRE/TTL, AOF + RDB persistence, pub/sub, master/replica log shipping, a single-threaded selectors event loop, and a benchmark against real Redis. Each step is one runnable Python file you read in one sitting. Source repo: github.com/learnwithparam/build-your-own-redis-python.
- Learning Outcomes: Parse and emit the RESP wire format, design a dispatch table for dozens of commands, implement lazy expiry with a sidecar dict, write crash-safe AOF + atomic-rename RDB snapshots with copy-on-write BGSAVE, fan-out pub/sub over TCP, ship master-replica log replication, replace one-thread-per-client with selectors, measure throughput and reason about the language-induced gap to real Redis

### Build your own Redis in Go
- URL: https://www.learnwithparam.com/courses/build-your-own-redis-go
- Level: Intermediate | ~9 hours | Free
- Description: Sibling of the Python Redis course, idiomatic Go. Ten steps: TCP echo with net.Listen + per-conn goroutines, RESP via bufio.Reader, sync.RWMutex-backed KV store, time.Time TTLs, AOF persistence, snapshot-then-save RDB (Go has no fork), channel-based pub/sub with write-pump goroutines, master/replica streaming, graceful shutdown with context.Context + signal.NotifyContext, benchmark vs real Redis. Source repo: github.com/learnwithparam/build-your-own-redis-go.
- Learning Outcomes: Build a concurrent TCP server with net.Listen and goroutines, use bufio.Reader for length-prefixed protocols, pick between sync.RWMutex / sync.Map / atomic, implement Go-style snapshot-then-save instead of fork, design buffered-channel fan-out with non-blocking select sends, stream replication across multiple replicas, wire context + signal + WaitGroup for graceful shutdown, reason about the gap to C Redis

### Build your own Redis in Node.js
- URL: https://www.learnwithparam.com/courses/build-your-own-redis-nodejs
- Level: Intermediate | ~8 hours | Free
- Description: Node sibling of the Python and Go Redis courses. Ten steps in idiomatic Node: net.createServer + per-connection data event handlers, Buffer + cursor RESP parser, Map-backed KV (no locks because single-threaded), Date.now TTLs with setInterval active sweep, fs.createWriteStream AOF, fs.writeFile + fs.rename RDB, Map<channel, Set<conn>> pub/sub, master/replica replication via net.connect + SYNC, process.on(SIGTERM) graceful shutdown, async worker-pool benchmark. Source repo: github.com/learnwithparam/build-your-own-redis-nodejs.
- Learning Outcomes: Build a multi-client TCP server with net.createServer, parse RESP from Buffer with a cursor, pick when single-threaded Node needs no locks vs when worker_threads earn their keep, implement TTLs with Date.now + setInterval, write AOF via createWriteStream and RDB via atomic rename, fan out pub/sub from Map + conn.write, stream replication over the same RESP wire, drain in-flight clients cleanly on SIGTERM, reason about Node's place between Python and Go on the throughput chart

### Build your own Redis in Rust
- URL: https://www.learnwithparam.com/courses/build-your-own-redis-rust
- Level: Intermediate | ~9 hours | Free
- Description: Rust sibling of the Python, Go, and Node Redis courses. Ten steps in idiomatic async Rust on tokio: TcpListener + tokio::spawn per conn, enum sum-type RESP parser, Arc<Mutex<HashMap>> store with match dispatch, Instant-based TTLs with lazy delete, tokio::fs AOF with the Option<&AofFile> pattern, atomic RDB via tokio::fs::rename (no fork), broadcast-channel pub/sub with select! reader/writer, master/replica via a broadcast feed + SYNC bootstrap, tokio::signal + watch-channel + Semaphore graceful shutdown, RESP load-generator benchmark vs real Redis. Source repo: github.com/learnwithparam/build-your-own-redis-rust.
- Learning Outcomes: Build a tokio TCP server with TcpListener and per-conn spawn, parse RESP with an enum sum type the compiler enforces, choose Arc<Mutex<T>> vs RwLock vs dashmap by access pattern, implement Instant-based TTLs with lazy delete, write AOF using the Option<&AofFile> pattern and atomic RDB via tokio::fs::rename, fan out pub/sub via tokio::sync::broadcast plus the select! reader/writer pattern, ship master/replica replication over the same RESP wire, coordinate graceful shutdown with tokio::signal + watch + Semaphore, reason about how Rust closes the gap to C Redis without losing memory safety

### Build your own Redis in Ruby
- URL: https://www.learnwithparam.com/courses/build-your-own-redis-ruby
- Level: Intermediate | ~8 hours | Free
- Description: Ruby sibling of the Python, Go, Node, and Rust Redis courses. Ten steps in pure-stdlib Ruby: TCPServer + Thread per connection, RESP parser via String#byteslice + tagged-array sum types, Hash + Mutex.synchronize for the store, Time-based TTLs with lazy delete, File.open('ab') AOF with log_to_aof flag, JSON RDB with atomic File.rename, per-subscriber Queue + write-pump Thread for pub/sub, master/replica replication via ARGV-driven role, Signal.trap + ConditionVariable graceful shutdown, percentile-based capstone benchmark. Source repo: github.com/learnwithparam/build-your-own-redis-ruby.
- Learning Outcomes: Build a concurrent TCP server with TCPServer + Thread per connection, parse RESP with byteslice and tagged-array tuples, understand when the GIL is enough vs when Mutex is required, implement TTLs that survive process restarts via AOF replay, snapshot in-memory state and write it atomically with File.rename, wire pub/sub fan-out using one Queue per subscriber + write-pump Thread, ship master/replica replication over the same RESP wire, coordinate graceful shutdown with Signal.trap and ConditionVariable

### Build your own Redis in Elixir
- URL: https://www.learnwithparam.com/courses/build-your-own-redis-elixir
- Level: Intermediate | ~8 hours | Free
- Description: Elixir sibling of every other Redis course, idiomatic OTP on the BEAM. Ten steps: gen_tcp + spawn per conn, RESP parser via binary pattern matching (the cleanest sibling), Agent then GenServer state, System.monotonic_time TTLs with lazy delete, File.open(:append) AOF with send-based replay, :erlang.term_to_binary RDB with atomic File.rename, Registry with keys: :duplicate for pub/sub (3 lines instead of 30), master/replica via the same Registry primitive, Process.flag(:trap_exit, true) + terminate/2 graceful shutdown (OTP gives this free), capstone benchmark. Source repo: github.com/learnwithparam/build-your-own-redis-elixir.
- Learning Outcomes: Build a gen_tcp server with one BEAM process per connection, parse RESP with binary pattern matching the compiler verifies, choose between Agent, GenServer, ETS, Registry by access pattern, implement monotonic_time-based TTLs with lazy delete, write AOF using File.open(:append) and send-based replay, fan out pub/sub via Registry plus send/2 in 3 lines, ship master/replica replication via the same Registry primitive, coordinate graceful shutdown with trap_exit and terminate/2 callbacks, reason about why OTP gives away what other languages have to engineer

### Long Document RAG with Conversational Memory
- URL: https://www.learnwithparam.com/courses/conversational-pdf-rag
- Level: Intermediate
- Description: Turn any PDF book into an AI tutor with chapter-aware chunking, semantic retrieval, and multi-turn conversational memory. Build a document QA system that handles follow-up questions without losing context.

### Video QA with Transcript Search and Timestamp Citations
- URL: https://www.learnwithparam.com/courses/video-rag-faiss
- Level: Intermediate
- Description: Transcribe YouTube videos, build a FAISS semantic index with BM25 hybrid retrieval, and answer questions with clickable timestamp citations using a Streamlit chat UI.

### Local Voice Transcription with Whisper and LLM Post-Processing
- URL: https://www.learnwithparam.com/courses/voice-transcription-whisper
- Level: Intermediate
- Description: Record audio in-browser, transcribe locally with Whisper, and clean output with LLM post-processing pipelines. Build an offline-first voice AI app with React, FastAPI, and faster-whisper.

### GenAI Observability with MLflow and Arize Phoenix
- URL: https://www.learnwithparam.com/courses/llm-observability-phoenix
- Level: Intermediate
- Description: Instrument SQL, RAG, and web search agent decisions with MLflow spans and Arize Phoenix dashboards. Learn to trace routing choices, track token cost per tool, and debug failing traces with full visibility.

### Building multi-provider LLM apps with OpenRouter
- URL: https://www.learnwithparam.com/courses/multi-llm-provider-pattern
- Level: Intermediate
- Description: Abstract OpenAI, OpenRouter, Gemini, and Ollama behind one chat() function with automatic fallback so you flip an env var to compare any two models without rewriting your app.

### Deploying AI applications with FastAPI and Docker
- URL: https://www.learnwithparam.com/courses/fastapi-ai-deployment-patterns
- Level: Intermediate
- Description: Production FastAPI patterns for AI apps. SSE streaming, background job queues, CORS and security headers, liveness vs readiness probes, request-id correlated JSON logs, multi-stage Dockerfiles, graceful shutdown.

### Building MCP servers for GitHub PR review
- URL: https://www.learnwithparam.com/courses/mcp-pr-review-server
- Level: Intermediate
- Description: Build an MCP server that fetches GitHub PR diffs, runs LLM code review, and posts structured review comments. Python MCP SDK, PyGithub, Claude Desktop wiring.

### Conversational state machines with LangGraph
- URL: https://www.learnwithparam.com/courses/conversational-state-machines-langgraph
- Level: Intermediate
- Description: Model multi-turn conversations as typed state machines. Intent routing, classification nodes, SQLite-backed data lookup, SSE streaming, thread memory for resume.

### Stateful agent workflows with LangGraph
- URL: https://www.learnwithparam.com/courses/stateful-agent-workflows-langgraph
- Level: Intermediate
- Description: Long-running stateful agents with LangGraph. Typed state, intent routers, slot-collection nodes, catalog lookups, propose-and-confirm flows, MemorySaver persistence.

### Supervisor-routed multi-agent systems with LangGraph
- URL: https://www.learnwithparam.com/courses/supervisor-multi-agent-langgraph
- Level: Intermediate
- Description: Compose specialist subagents behind an LLM supervisor. Shared typed state, RAG/SQL/hybrid subagents, handoff protocol, per-agent SSE streaming, multi-turn memory.

### Full-stack agentic AI with Next.js and LangGraph
- URL: https://www.learnwithparam.com/courses/fullstack-agents-nextjs
- Level: Advanced
- Description: Production agents in Next.js 15 with Vercel AI SDK. Tool calling, multi-step reasoning, streaming UX, input/output guardrails, provider swap, DB-backed thread memory.

### Building coding agents from scratch in Go
- URL: https://www.learnwithparam.com/courses/coding-agents-from-scratch-go
- Level: Advanced
- Description: Build a coding agent in pure Go stdlib. LLM calls over net/http, tool loop closure, read_file, write_file with path safety, sandboxed run_bash, iteration caps, distroless ship.

### Advanced RAG with query rewriting and evaluation
- URL: https://www.learnwithparam.com/courses/advanced-rag-evaluation
- Level: Advanced
- Description: Add LLM query rewriting, sub-graph decomposition, PII scrubbing with Presidio, RAGAS evaluation metrics, offline eval harness with regression thresholds, live-score streaming.

### Graph RAG with LangChain and Neo4j
- URL: https://www.learnwithparam.com/courses/graph-rag-neo4j
- Level: Advanced
- Description: Extract entities and relationships with LLMs, store in Neo4j, answer with GraphCypherQAChain. Side-by-side vector vs graph RAG, hybrid retrieval, auto-generated schema prompts.

### Enterprise RAG infrastructure with Kubernetes and Ray
- URL: https://www.learnwithparam.com/courses/enterprise-rag-kubernetes-ray
- Level: Advanced
- Description: Scale RAG with Ray actors for parallel embedding, containerize with multi-stage Docker, deploy to Kubernetes with Deployment/Service/Ingress, secrets via ConfigMap, horizontal autoscale with HPA.

### Build an RBAC-gated RAG chatbot with per-role document walls
- URL: https://www.learnwithparam.com/courses/rbac-rag-chatbot
- Level: Intermediate | ~6 hours
- Description: Ship a role-gated RAG chatbot where finance, engineering, and admin users only see their own documents. Per-role ChromaDB collections, PBKDF2 session auth, sliding-window rate limits, local sentence-transformer embeddings, and a Gradio admin panel for managing users and documents without a redeploy.
- Learning Outcomes: Enforce RBAC at the retrieval layer with per-role collections, hash passwords with PBKDF2 and per-user salts, issue auto-renewing session tokens with lockout, run local sentence-transformers embeddings, wire OpenRouter generation behind a provider abstraction, apply sliding-window rate limits per username, operate an admin flow for users and documents.

### Layered production AI architecture
- URL: https://www.learnwithparam.com/courses/layered-production-ai-architecture
- Level: Advanced
- Description: Build a production agent as composable layers. Transport, orchestrator state machine, tools registry, thread memory, retrieval, I/O guardrails, observability with per-layer traces.

### Sentiment classification with LLMs and few-shot prompting
- URL: https://www.learnwithparam.com/courses/sentiment-classification-llms
- Level: Beginner
- Description: Start with a single sentiment classifier and grow into a multi-task NLP agent. Structured JSON with Pydantic, pluggable task registry, optional LangGraph fan-out, SSE streaming, resilient error handling.

### Real-time phone agents with FastRTC
- URL: https://www.learnwithparam.com/courses/realtime-phone-agents-fastrtc
- Level: Advanced
- Description: Build low-latency phone agents over WebRTC. FastRTC signaling, audio frame handling, streaming STT with Whisper, chunked TTS, phone persona prompting, tool calls mid-call, barge-in and turn detection.

---

## Blog (130+ articles)
- URL: https://www.learnwithparam.com/blog
- RSS: https://www.learnwithparam.com/rss.xml
- Categories: AI Engineering, AI Engineering in Practice, LLM Engineering, Prompt Engineering
- Topics covered: AI agents, RAG pipelines, prompt engineering, LLMs, system design, MCP, vector databases, multi-agent systems, embeddings, tool calling, agentic workflows
- Format: Technical deep-dives, practical tutorials, and architecture guides for AI engineers
- Updated regularly with new articles on production AI engineering patterns

### Which language should you build Redis in? Lessons from rebuilding it 6 times
- URL: https://www.learnwithparam.com/blog/which-language-should-you-build-redis-in
- Category: Backend Engineering
- Description: Honest comparison of building a Redis clone in Python, Go, Node.js, Rust, Ruby, and Elixir. Concurrency model, idioms, throughput, where each language wins and where it costs you. Companion to the Build your own Redis 6-language course series.

---

## Ebooks & Cheatsheets (free, lead-gated)
- URL: https://www.learnwithparam.com/ebooks

### The RAG Cheatsheet
- URL: https://www.learnwithparam.com/ebooks/rag-cheatsheet
- Focus: Chunking strategies, hybrid retrieval wiring, reranking payoff, evaluation metrics, failure-mode triage. Companion to the Agentic RAG Masterclass.

### AI Engineer Interview Prep Guide
- URL: https://www.learnwithparam.com/ebooks/ai-engineer-interview-prep-guide
- Focus: Scope by level, recurring technical questions, system-design patterns for LLM products, portfolio shapes, focused prep plan. Companion to Learn AI Agents from Scratch.

---

## Platform Features
- Interactive, chat-based lessons (not videos)
- Built-in code exercises, quizzes, and validation checklists
- Progress tracking with XP system and achievements
- Works on your machine with real repos and production-grade code
- Self-paced learning with no deadlines
- Free plan for signed-in members; a Pro subscription (monthly, yearly, or lifetime) unlocks all paid content

## Frequently Asked Questions

Q: What makes learnwithparam different from other AI courses?
A: Every course is hands-on and code-first. You clone real repos, build projects on your machine, and run production-grade code. There are no videos. It's like pair-programming with a senior engineer through an interactive chat-based platform. https://www.learnwithparam.com/resources

Q: What's the best learning path for someone new to AI engineering?
A: Start with Python for GenAI Engineering, then GenAI Masterclass: Go from Zero to One, followed by Prompt Engineering Crash Course. All three are free. From there, move to RAG Fundamentals for Everyone and Learn AI Agents from Scratch. https://www.learnwithparam.com/resources

Q: Do I need machine learning or data science experience?
A: No. The courses teach you to use LLMs and AI tools as a software engineer, not as a researcher. You start from Python basics and build up to production systems. https://www.learnwithparam.com/courses/python-for-genai

Q: What is RAG and which course teaches it?
A: RAG (Retrieval-Augmented Generation) connects LLMs to external documents so they can answer questions about your data. RAG Fundamentals for Everyone teaches embeddings, vector stores, chunking, and building a complete pipeline with source attribution. https://www.learnwithparam.com/courses/rag-fundamentals

Q: How do I learn to build AI agents?
A: Learn AI Agents from Scratch teaches you to build agents from scratch (memory, tool calling, ReAct loops, and error recovery) without relying on frameworks. For advanced patterns, follow up with Advanced Design Patterns in AI Agents. https://www.learnwithparam.com/courses/ai-agents-fundamentals

Q: What is MCP and why should I learn it?
A: MCP (Model Context Protocol) is a standard protocol that lets AI applications connect to external tools and data sources. Instead of writing custom integration code for every tool, you build one MCP server and any AI client can use it. https://www.learnwithparam.com/courses/mcp-fundamentals

Q: What is the AI Bootcamp for Software Engineers?
A: A structured 6-week program that takes you from software engineer to AI engineer. It includes live sessions, pre-recorded content, real challenges, and a capstone project. The live mentor-led cohort is a one-time purchase, while the self-study content is covered by a Pro subscription. Regional pricing available. See the page for current pricing in your region. https://www.learnwithparam.com/ai-bootcamp

Q: Are there free courses available?
A: Yes. Seven interactive courses are completely free: Python for GenAI Engineering, GenAI Masterclass, Prompt Engineering Crash Course, RAG Fundamentals for Everyone, Learn AI Agents from Scratch, Advanced Design Patterns in AI Agents, and MCP Fundamentals for Engineers. https://www.learnwithparam.com/resources

Q: Can I use what I learn at work immediately?
A: Absolutely. Every program and course builds production-grade systems with real architecture patterns. Engineers from NVIDIA, Microsoft, Wise, Grab, and other companies use these programs to ship AI features. https://www.learnwithparam.com/programs

Q: What programming language do the courses use?
A: The AI courses use Python, the standard language for AI/ML engineering. The Python for GenAI Engineering course covers everything you need if you're new to Python. The backend and frontend bootcamps use Node.js, TypeScript, and Next.js. https://www.learnwithparam.com/courses/python-for-genai

Q: How is Advanced Design Patterns in AI Agents different from Learn AI Agents from Scratch?
A: Learn AI Agents from Scratch teaches you to build a single agent from scratch. Advanced Design Patterns in AI Agents covers the full catalog of production patterns: prompt chaining, parallelization, multi-agent coordination, safety guardrails, and metacognitive reasoning. https://www.learnwithparam.com/courses/ai-agent-design-patterns

Q: What is Learn to Build your own Coding Agent about?
A: You reverse-engineer Claude Code's architecture and build your own AI coding agent from scratch. Covers the agent loop, tool design, context compaction, multi-agent teams, and git worktree isolation. It's the most advanced AI course on the platform. https://www.learnwithparam.com/courses/build-your-own-coding-agent

Q: Who is Param Harrison?
A: Param Harrison is a Head of Engineering with 15+ years of experience who created learnwithparam. He teaches AI engineering and full-stack development through hands-on courses used by engineers at companies like NVIDIA, Microsoft, Grab, and Wise. https://www.learnwithparam.com/about

Q: What's the difference between programs and courses?
A: Programs are structured bootcamps or masterclasses with a clear learning path, often bundling multiple courses (e.g. AI Bootcamp, Complete Full Stack Bootcamp). Standalone courses on the /courses page are individual self-paced courses you can take on their own. https://www.learnwithparam.com/programs

Q: Is there a community or support available?
A: Yes. There's a Skool community where learners discuss projects, ask questions, and share progress. The AI Bootcamp mentor-led tier also includes direct mentorship and live Q&A sessions with Param. https://www.learnwithparam.com/ai-bootcamp

## Contact
- Website: https://www.learnwithparam.com
- Twitter: https://twitter.com/learnwithparam
- GitHub: https://github.com/learnwithparam
- LinkedIn: https://linkedin.com/in/paramanantham