Free, hands-on tutorials in Python, Java, JavaScript, TypeScript, Angular, Node.js, DSA, system design, databases and Docker — as readable lessons or 30-second shorts, in English and Hindi.
Go (Golang) — Learn Go by running it: modules and packages, types and zero values, slices and maps, structs, interfaces and generics, errors, goroutines, channels, context, the race detector, net/http, JSON, testing and tooling, all executed with Go 1.27. (26 lessons)
JavaScript Fundamentals: From Syntax to Async — Learn JavaScript from variables and functions to the DOM, classes, promises and modules. For beginners starting web development. (40 lessons)
Kotlin — Learn modern Kotlin from the basics to production: null safety, data and sealed classes, functional collections, coroutines and Flow, Java interop, testing and the server, Android and Multiplatform ecosystem. (25 lessons)
Python Fundamentals: From Basics to Async — Learn Python from variables to classes, generators, decorators and async. For beginners and career switchers who want practical scripting and backend skills. (49 lessons)
Rust — Learn Rust by compiling it: cargo, ownership and borrowing, lifetimes, structs, enums and traits, Result and the ? operator, iterators, fearless concurrency with Send and Sync, and testing with clippy and rustfmt, with real compiler output from Rust 1.99. (25 lessons)
TypeScript Fundamentals — Learn TypeScript types, generics and strict mode to catch bugs before runtime. A hands-on course for JavaScript developers. (28 lessons)
Bash / Shell Scripting — Build practical foundations in Bash / Shell Scripting, from first scripts to reliable programs. (25 lessons, Coming soon)
C++ — From your first compiled program to STL, memory, and interview-ready problem solving. (25 lessons, Coming soon)
Design Patterns — Learn the classic design patterns through realistic TypeScript examples: what each one is for, when it helps, when it is over-engineering, and the modern alternatives that often replace it. (25 lessons)
Operating System Concepts — Build practical foundations in Operating System Concepts. (25 lessons, Coming soon)
Frontend Development
Web Accessibility (A11y) — Build accessible websites with WCAG 2.2, semantic HTML, ARIA and keyboard patterns, and test with automated tools and screen readers. (26 lessons)
AI Visibility and LLM Brand Discovery — Learn how people discover brands through AI assistants and how to be found, cited and described accurately: crawlers, structured data, content, measurement and ethics. (25 lessons)
Angular Fundamentals: Components, Signals and Routing — Learn modern Angular with standalone components, templates, signals, routing, forms and HttpClient. For front-end developers building structured apps. (32 lessons)
Babel and SWC: JavaScript Transpilation and Build Speed — Learn how Babel and SWC transpile modern JavaScript, JSX and TypeScript, target browsers and Node, and speed up builds. For front-end and tooling developers. (31 lessons)
Next.js — Build full-stack React apps with the Next.js App Router: layouts, dynamic routes, Server and Client Components, static and dynamic rendering, caching, Server Actions, Route Handlers, Proxy, metadata and deployment, verified against a real Next.js 16 build. (25 lessons)
Progressive Web Apps: Offline, Installable Web Apps — Build installable, offline-capable web apps with manifests, service workers, caching and push. For front-end developers moving beyond static pages. (30 lessons)
React — Learn modern React by running it: JSX, components and props, state and batching, effects and data fetching, forms, reducers, context, custom hooks, refs, memoisation, keys, error boundaries and testing, with every example executed on React 19. (25 lessons)
React Native — Build native iOS and Android apps with React: core components, Flexbox layout, lists and input, navigation, data, device APIs, performance and shipping to the stores with Expo and EAS. (25 lessons)
Redux Toolkit / Zustand — Manage client state in React apps with Redux Toolkit, RTK Query and Zustand: slices, async logic, caching, selectors, middleware, testing and choosing the right tool. (25 lessons)
Responsive and Mobile-First Web Design — Build fluid, mobile-first layouts with media queries, Flexbox, Grid and container queries. For front-end developers who want sites that work on every screen. (26 lessons)
SEO for Developers: Technical SEO and Core Web Vitals — Learn technical SEO: crawlability, structured data, rendering and Core Web Vitals. For developers who want sites that rank and earn organic traffic. (34 lessons)
Storybook: Component-Driven UI Development — Build, document and test UI components in isolation with Storybook. For front-end developers and design-system teams working in React. (25 lessons)
Svelte / SvelteKit — Build fast web apps with Svelte 5 runes and SvelteKit 2: reactive components, snippets, shared state, filesystem routing, server data loading, form actions, adapters and testing. (25 lessons)
Tailwind CSS — Style interfaces directly in your markup with utility classes: layouts, responsive design, states, dark mode, design tokens and maintainable component patterns, using Tailwind CSS v4. (25 lessons)
Vue.js — Build modern web apps with Vue 3: templates and reactivity, components and composables, routing with Vue Router, state with Pinia, TypeScript, testing and performance. (25 lessons)
Web Performance Optimization — Measure and improve page speed with Core Web Vitals, DevTools and Lighthouse. Apply proven fixes for images, JavaScript, caching and delivery. (25 lessons)
Webpack: Module Bundling and Build Optimization — Learn to configure, optimize and debug Webpack builds for front-end projects. Ship smaller, faster bundles with a production-ready setup. (25 lessons)
API Design and Versioning — Design APIs people can rely on: resources, HTTP semantics, errors, pagination, idempotency, security, versioning, deprecation and governance, tested with a real running API. (27 lessons)
Authentication & Authorization — Build identity systems that hold up: password storage, sessions and cookies, JWTs, OAuth 2.0 and OpenID Connect, MFA and passkeys, and authorization models enforced in real APIs. (25 lessons)
Django / FastAPI — Build Python web backends two ways: FastAPI for typed, async APIs with Pydantic and dependency injection, and Django for full-stack apps with its ORM, migrations, forms and admin, with every example run on Django 6.1 and FastAPI 0.142. (26 lessons)
.NET Core: Build, Test and Ship Web APIs — Learn modern .NET from the CLI to ASP.NET Core APIs, dependency injection, EF Core, auth, testing and Docker. (26 lessons)
Fastify: Building High-Performance Node.js APIs — Build fast Node.js APIs with Fastify routing, JSON Schema validation, plugins, hooks and JWT auth. For developers who want an Express alternative. (32 lessons)
Firebase — Build apps on Firebase with the modular JavaScript SDK: Authentication, Firestore modelling and queries, Security Rules, Storage, Cloud Functions, Hosting and production practices. (25 lessons)
GraphQL — Design and build GraphQL APIs: schemas in SDL, queries and mutations, resolvers without N+1 problems, client caching, pagination, security limits and schema evolution. (25 lessons)
gRPC — High-performance service-to-service APIs: Protocol Buffers schemas, unary and streaming RPCs, deadlines and status codes, authentication and interceptors, load balancing and production practices. (25 lessons)
Apache Kafka: Event Streaming from Basics to Production — Learn Apache Kafka: topics, partitions, producers, consumer groups, delivery guarantees, retention, replication, exactly-once and operations, checked against a real broker. (25 lessons)
NestJS: Building Scalable Node.js APIs — Build structured, testable server-side apps with NestJS modules, dependency injection, TypeORM and guards. For TypeScript and Node.js developers. (34 lessons)
Node.js Fundamentals: Modules, Async and Servers — Learn Node.js from modules and npm to async code, streams and a basic HTTP server. For JavaScript developers moving to backend and tooling work. (30 lessons)
OWASP Top 10 — Understand the most critical web application security risks and how to prevent them, with vulnerable and fixed code side by side for access control, injection, cryptography, configuration, components, authentication and monitoring. (25 lessons)
REST API Design: Resources, Status Codes and Security — Design clean, predictable HTTP APIs: resources, status codes, pagination, versioning, authentication and errors. For backend and full-stack developers. (25 lessons)
Spring Boot — Build production-ready Java services with Spring Boot 4: starters and auto-configuration, dependency injection, REST controllers, validation, problem details, Spring Data JPA, transactions, slice tests and Actuator, verified with a real app built and run. (25 lessons)
Stripe Payments — Integrate Stripe end to end: Checkout and Payment Element, webhooks, SCA and saved cards, subscriptions, refunds and disputes, Connect, idempotency and a production checklist. (25 lessons)
Supabase — Build on Supabase: Postgres tables and supabase-js queries, Row Level Security, auth, storage, realtime, edge functions, the CLI workflow and a production-ready checklist. (25 lessons)
Cron & Scheduled Jobs — Build practical foundations in Cron & Scheduled Jobs. (25 lessons, Coming soon)
Elasticsearch — Build fast, relevant search and analytics: inverted indexes, mappings and analyzers, the Query DSL, aggregations, autocomplete and vector search, plus the operations that keep a cluster healthy. (25 lessons)
MongoDB Fundamentals: Documents, Queries and Indexes — Learn MongoDB from documents and CRUD to indexes, aggregation, schema design and replication. For developers building apps with flexible data. (23 lessons)
MySQL Fundamentals: SQL, Joins and Transactions — Learn MySQL and SQL from tables and queries to joins, indexes and transactions. For beginners and developers who need to work with relational data. (30 lessons)
PostgreSQL — Learn PostgreSQL by running it: schema design and constraints, joins and aggregates, CTEs and window functions, JSONB, upserts, EXPLAIN and indexes, transactions and isolation, roles, row-level security and backups, all executed on PostgreSQL 16. (25 lessons)
SQL Deep Dive — Go beyond SELECT * : how SQL evaluates queries, joins without surprises, window functions, recursive CTEs, analytical patterns and index-friendly queries, with every query run on PostgreSQL 16. (25 lessons)
Vector Databases — Learn to store, index, filter and operate vectors in real systems: pgvector with SQL, Qdrant and Chroma APIs, HNSW tuning, filtered and hybrid search, sharding, replication, capacity planning, security and choosing a database, with every example run for real. (28 lessons)
Ansible: Automate Servers with Playbooks — Learn agentless automation with Ansible: inventories, playbooks, variables, templates, handlers, roles, Vault and safe production rollouts, with real runnable examples. (26 lessons)
AWS Fundamentals: Core Services for Cloud Beginners — Learn core AWS services: IAM, EC2, S3, RDS, VPC, Lambda, CloudFront and CloudWatch, plus cost control. For beginners moving to the cloud. (28 lessons)
CI/CD Fundamentals: Pipelines, Testing and Deployment — Learn CI/CD concepts and GitHub Actions: pipelines, automated testing, environments, deployment strategies and secrets. For developers and DevOps beginners. (23 lessons)
Docker Fundamentals: Images, Containers and Compose — Learn Docker from images and containers to Dockerfiles, volumes, networking and Compose. For developers who want consistent environments. (28 lessons)
Docker Compose — Run multi-container apps with Docker Compose: services and builds, environment and interpolation, health checks and startup order, volumes, secrets, networks, override files and profiles, with every configuration checked by docker compose config. (25 lessons)
GitHub Actions — Automate CI/CD with GitHub Actions: workflow anatomy, triggers and filters, jobs and needs, matrices and expressions, caching and concurrency, token permissions, script injection, pinning, reusable workflows and deployments, with every workflow checked by actionlint. (25 lessons)
Kubernetes — Run containers reliably with Kubernetes: architecture, Pods and Deployments, Services, ConfigMaps and Secrets, scheduling and resources, probes, rolling updates, autoscaling, Kustomize, storage and security, with kubectl output and Python models run. (25 lessons)
Linux Command Line Fundamentals — Learn the Linux command line: files, permissions, processes, text tools, scripting, SSH and services. For developers and aspiring DevOps engineers. (31 lessons)
OpenTelemetry — Vendor-neutral observability: instrument services once for traces, metrics and logs, propagate context across services, and process telemetry with the OpenTelemetry Collector before sending it to any backend. (25 lessons)
Prometheus + Grafana — Monitor systems with metrics: instrument services, scrape them with Prometheus, query with PromQL, alert with Alertmanager and visualise everything in Grafana dashboards. (25 lessons)
Terraform — Manage infrastructure as code with Terraform: providers, resources, variables, plans, state and drift, count and for_each, modules, sensitive values, lifecycle rules, refactoring with moved blocks and CI workflows, with every command run on Terraform 1.16. (25 lessons)
API Gateway and Service Mesh — Learn how API gateways and service meshes route, secure, protect and observe traffic: routing, canaries, rate limits, retries, circuit breakers, mTLS and operations, tested on a real gateway. (26 lessons)
High-Level & Low-Level Design Interview Problems — Worked high-level and object-oriented design problems, from parking lots and LRU caches to ride-hailing, payment ledgers and collaborative editors, with the trade-offs interviewers look for. (25 lessons)
System Design: Architecture, Scale and Trade-offs — Learn system design: estimate load, choose building blocks and weigh trade-offs for scalable, reliable systems. Built for engineers and interviews. (32 lessons)
Playwright & Cypress — Write reliable end-to-end browser tests with Playwright and Cypress: locators and assertions, authentication, network mocking, debugging flaky tests, visual and accessibility checks, and running at scale in CI. (25 lessons)
Jest, Vitest & Testing Library — Write fast, trustworthy unit, integration and component tests for TypeScript frontends with Jest or Vitest, Mock Service Worker and Testing Library. (25 lessons)
API Testing — Build practical foundations in API Testing. (25 lessons, Coming soon)
Agent Frameworks and MCP Basics — Understand the agent loop, tool calling, framework trade-offs and the Model Context Protocol, then build and secure your first MCP server. (25 lessons)
Agent Loops, Stop Conditions and Token Budgets — Learn how agent loops grow in cost, how to stop them safely, and how to budget tokens, time and money with guards, caching and graceful endings. (25 lessons)
Advanced Agent Workflows and Skills — Design reliable AI agent workflows: patterns, skills, subagents, hooks, context management, evals and safe automation. (25 lessons)
AI Agents and Tool Use — Learn how AI agents use tools: ReAct and planning, tool schemas, tool design, safety, evaluation and multi-agent patterns, with working Python examples. (25 lessons)
Estimating AI Automation ROI — Build AI business cases that survive contact with reality: measured baselines, task decomposition, review time, total cost of ownership, NPV and payback, sensitivity and Monte Carlo, adoption ramps and post-launch measurement, with every model run. (25 lessons)
Safe Rollout Plans for AI Features — Ship LLM features without surprises: launch bars, red-team gates, cost budgets, feature flags, staged ramps, shadow and canary tests, fallbacks, spend caps, rollback triggers and model upgrades, with every calculation run. (25 lessons)
AI Safety, Evaluation and Cost Control — Build LLM applications that are safe, measurable and affordable: safeguards, evaluation metrics, monitoring and cost control, with runnable Python examples. (25 lessons)
AI Strategy, Ethics and Governance — Plan AI adoption that delivers value responsibly: choosing use cases, building the business case, applying ethics, managing risk, setting governance and tracking regulation. (26 lessons)
Apache Airflow: Orchestrate Data Pipelines — Learn to schedule and monitor workflows with Apache Airflow: DAGs, TaskFlow, scheduling, XComs, branching, sensors, retries, idempotent design and deployment. (25 lessons)
Artificial Intelligence — The foundations of AI in one course: agents, search, A*, game playing, constraints, logic, probability, decisions, learning, reinforcement learning, language models and ethics, with every algorithm implemented and run in plain Python. (25 lessons)
Claude Code Skills & SKILL.md — Package your know-how as reusable skills: SKILL.md structure, descriptions that trigger, supporting scripts and references, testing, security review and team sharing, with validators and a script harness you can run. (26 lessons)
AI Coding-Agent Guardrails — Design layered guardrails for AI coding agents: permissions, sandboxes, secret and network controls, Git and CI gates, hooks, logging and incident response. (25 lessons)
Coding Agents & AI-Assisted Development — Understand how coding agents work and use them well: the agent loop, tools, edit formats, context, instruction files, test-driven workflows, parallel agents, verification, evaluation, cost and team practice, with a working mini agent you can run. (29 lessons)
Computer Vision — From pixels to production: image processing with OpenCV, keypoints, augmentation, pretrained classification, transfer learning, object detection, segmentation, evaluation metrics and robustness, with every example run on real sample images. (26 lessons)
Deep Learning & Neural Networks — Understand and build neural networks: neurons, backpropagation, PyTorch training loops, regularisation, CNNs, embeddings, attention, transformers and transfer learning, with every example run on CPU. (25 lessons)
Dify Workflow Basics — Build LLM apps visually with Dify: workflows and chatflows, prompts and variables, knowledge bases, routing, iteration, code nodes, structured extraction, API calls and streaming, with runnable Python for every testable piece. (25 lessons)
Embeddings & Vector Search — Understand how text becomes vectors and how to search them: similarity measures, learned embeddings, exact and approximate nearest neighbours, quantisation, hybrid search, evaluation and production, with every experiment run for real. (28 lessons)
Fine-tuning vs Prompting — Decide between prompting, retrieval and fine-tuning with evidence: how training changes a model, LoRA and other efficient methods, data quality, forgetting, evaluation and cost, with small real training experiments you can run. (27 lessons)
LangChain / LlamaIndex — Build LLM applications with LangChain and LlamaIndex: prompts, runnables, parsers, tools, retrieval, indexes, query engines, agents and testing, with examples run offline using fake models. (31 lessons)
LangGraph Agents & Multi-Agent Systems — Build reliable agents as graphs: state, nodes, edges, loops, tools, memory, human approval, streaming, sub-graphs and multi-agent supervisors, with every example run for real offline. (29 lessons)
Claude API / OpenAI API Basics — Call LLM APIs confidently: requests and responses, messages, parameters, streaming, tool use, errors and retries, cost, security and testing, with the real Anthropic and OpenAI SDKs run against a local stand-in server. (27 lessons)
LLM Engineering Foundations — Turn LLM demos into dependable products: evaluation and statistics, prompt and model versioning, structured output, cost and latency engineering, reliability and observability, serving, governance and team practice, with every experiment run. (29 lessons)
LLM Application Security — Secure applications built on language models: prompt injection, unsafe output handling, excessive agency, data leaks, RAG access control, supply chain, abuse and cost attacks, testing and incident response, with attacks and defences you can run. (28 lessons)
Large Language Models — Understand how LLMs work from tokens and embeddings to attention, training, prompting, evaluation, safety and deployment, with small runnable models you can verify. (27 lessons)
Machine Learning Basics — Learn machine learning by doing it: data splits, regression, classification, metrics, overfitting, cross-validation, ensembles and unsupervised learning, with every scikit-learn example run on real bundled datasets. (25 lessons)
MCP & Agent-to-Agent Protocols — Understand the protocols that connect AI agents to tools and to each other: MCP internals, building and securing servers, A2A agent cards and tasks, and how the two fit together, with a real server driven over JSON-RPC. (31 lessons)
MLOps — Take models from notebook to reliable production: experiment tracking, reproducibility, data validation, registries, CI gates, serving, shadow and canary releases, drift monitoring and retraining, with MLflow and scikit-learn examples run. (25 lessons)
AI Automation with n8n — Build, secure and run AI-powered workflows in n8n: triggers, data handling, the AI Agent node, tools, RAG, error handling, guardrails and self-hosting. (25 lessons)
NumPy / Pandas / scikit-learn — The core Python data stack, hands on: fast arrays with NumPy, data wrangling with pandas, and honest machine learning with scikit-learn, with every example run on NumPy 2.5, pandas 3.0 and scikit-learn 1.9. (25 lessons)
OpenAI Agent Builder Workflows — Design agent workflows on a visual canvas and in code: nodes, state, routing, loops, handoffs, approvals, guardrails, evals, versioning and cost, with runnable Agents SDK and Python snippets. (26 lessons)
Prompt & Context Engineering — Go beyond wording: decide what the model sees, how much, in what order and in what structure. Token budgets, retrieval packing, compression, memory, caching, structured output and untrusted content, with every snippet run. (25 lessons)
Prompt Engineering — Write prompts that work reliably: structure, examples, reasoning, structured output, context limits, safety and evaluation, with small runnable harnesses to test your prompts. (29 lessons)
Prompt Quality Scoring — Measure prompts instead of guessing: prompt linting, format checks, weighted rubrics, calibrated LLM judges, bias checks, pairwise ratings, significance tests, cost-quality frontiers and regression gates, with every calculation run. (25 lessons)
Retrieval-Augmented Generation (RAG) — Build question-answering systems grounded in your own documents: chunking, embeddings, keyword and hybrid search, reranking, prompts, citations, evaluation and production concerns, with small runnable examples. (27 lessons)
RAG Retrieval & Evaluation — Measure a RAG system instead of eyeballing it: evaluation sets, retrieval metrics, statistics, retriever and chunking experiments, answer faithfulness, calibrated LLM judges and release gates, with every snippet run. (25 lessons)
Safe Autonomous Code Fixing — Let AI fix bugs without breaking trust: reproduce with failing tests, localise with traces and git bisect, keep patches minimal, verify in isolation, detect test tampering and secrets, review and revert safely, with every step run in Python and real git. (25 lessons)
Apache Spark: Big Data Processing with DataFrames — Learn Apache Spark with PySpark: architecture, DataFrames, SQL, joins, windows, lazy execution, shuffles, performance tuning, streaming and production deployment. (25 lessons)
Data Warehousing & Modelling — Build practical foundations in Data Warehousing & Modelling. (25 lessons, Coming soon)
1Password and Secrets Hygiene for Developers — Learn to store, share, use and rotate passwords, API keys and tokens safely with 1Password, the op CLI and good Git habits. (24 lessons)
Bun — Build practical foundations in Bun. (25 lessons, Coming soon)
VS Code — Build practical foundations in VS Code. (25 lessons, Coming soon)
Career & Interview Prep
Behavioural Interview Prep — Prepare for behavioural interviews as a software engineer: how answers are assessed, the STAR method, a reusable story bank, the core question types, level-specific expectations and practical delivery. (25 lessons)
DSA Interview Patterns — Recognise the twenty or so patterns behind most coding interview questions and explain your solution clearly, with every solution written in Python and run against test cases. (26 lessons)
Resume & GitHub Portfolio — Build an honest, focused software engineering resume and a GitHub portfolio that shows real skill: strong bullets, tailoring, readable formatting, project READMEs, code quality signals and a final checklist. (25 lessons)
System Design Interview Prep — Practise structured, defensible design conversations: a repeatable interview framework, back-of-envelope maths, the core building blocks and classic case studies, with the key numbers computed by small Python simulations you can run. (25 lessons)
Freelancing & Remote Work Basics — Build a safe, professional and repeatable independent-work practice. (25 lessons, Coming soon)
Open Source Contribution Guide — Learn to make respectful, reviewable contributions to real projects. (25 lessons, Coming soon)