63 programmes · 21 tracks
Find your next internship.
Computer-science internships from Rs. 199 to Rs. 999 + GST. Every programme is at least 40 hours, ends in a capstone assessment and earns an internship certificate anyone can verify. Open any programme to read its first lesson free, or fill a cart and pay for several at once.
- 63programmes
- 40+hours each
- Rs. 199to start, + GST
- Freefirst lesson
Learning paths
A whole track in one order, at a discount.
Go from how the web works to a deployed task manager of your own: a browser front end, a Node.js REST API and a PostgreSQL database, in 19 parts and 40 hours that you finish at your own pace.
- HTML and CSS
- JavaScript
- Node.js
Take your first web project to the next level: user accounts, safe sessions, authorisation, validation, automated tests and a well-designed database, finished with a capstone that the NIBVEDA team reviews.
- Authentication
- Authorisation
- Input validation
Design, harden, test, observe and ship a web system the way a production team does: architecture trade-offs, caching, observability, security hardening, containers and a CI/CD pipeline, finished with a detailed capstone review.
- System design
- Observability
- Performance tuning
Learn Linux, Git, Docker and continuous integration by shipping one small application through an automated pipeline, from your laptop to a running server.
- Linux
- Git workflow
- Docker
Stop building servers by hand. Describe infrastructure in code, run containers on Kubernetes, and watch your system with metrics, logs and alerts, finishing with a reproducible environment that the NIBVEDA team reviews.
- Terraform
- Ansible
- Kubernetes
Run systems that must not fail: service level objectives, safe release strategies, cloud security and policy as code, secure pipelines, disaster recovery and cost control, finished with a production-grade platform reviewed by the NIBVEDA team.
- Site reliability
- Progressive delivery
- Cloud security
Learn Python for data, clean and explore a real dataset, and train and honestly evaluate your first machine-learning model, finishing with a short report of your own.
- Python
- pandas
- Data cleaning
Go beyond your first model. Engineer features, validate without fooling yourself, handle imbalanced data and time series, explain what a model learned, and track experiments reproducibly, finishing with a predictive-model report reviewed by the NIBVEDA team.
- Feature engineering
- Cross-validation
- Gradient boosting
Train neural networks, work with text, then take a model into production: serve it, test it, monitor it for drift, schedule data pipelines, design experiments properly and review risks, finishing with an end-to-end ML system reviewed by the NIBVEDA team.
- PyTorch
- NLP
- Model serving
Learn the core ideas of security, find and fix the most common web vulnerabilities in a safe practice application, and write a real security report.
- Threat modelling
- OWASP Top 10
- Authentication
Move from knowing the vulnerabilities to working with them: map the attack surface of a practice target, exploit and fix deeper web flaws, use cryptography correctly, harden systems, and write detections that catch real attacks, finishing with a security assessment reviewed by the NIBVEDA team.
- Reconnaissance
- Web penetration testing
- Cryptography in practice
Think like the owner of a security programme: model threats at scale with ATT&CK, design identity and architecture that resist attack, investigate incidents with forensic evidence, run vulnerability and testing programmes, and govern risk, finishing with a security programme for an organisation reviewed by the NIBVEDA team.
- Threat modelling
- Security architecture
- Digital forensics
Learn Python from scratch by building real programs: a unit converter, a to-do manager with saved data, a tested module and a text game, finishing with a command-line application of your own.
- Python
- Problem solving
- Functions and modules
Learn the data structures and algorithms behind fast software by implementing them yourself in Python: complexity, hashing, stacks, queues, trees, heaps, sorting and graphs, with tests and benchmarks.
- Data structures
- Algorithms
- Big-O analysis
Master the techniques behind hard problems: dynamic programming, greedy proofs, shortest paths and spanning trees, advanced data structures, backtracking and string algorithms, ending with an algorithm-engineering project with benchmarks.
- Dynamic programming
- Graph algorithms
- Algorithm design
Learn SQL from the first query to joins and transactions, design a clean database for a real scenario, and connect it to a Python program, finishing with a complete data-backed application.
- SQL
- Database design
- Joins and aggregation
Build a real backend API in Python with FastAPI and PostgreSQL: REST design, validation, authentication, transactions and concurrency, query performance, testing and containers, ending with a production-style service.
- REST API design
- FastAPI
- PostgreSQL
Learn how production backends handle load and failure: caching with Redis, background work with queues, database scaling, rate limiting, retries and circuit breakers, observability and load testing, finishing with a measured, resilient service.
- Caching with Redis
- Message queues
- System design
Learn Dart and Flutter by building real screens and apps: layouts, interactive state, navigation, saved data and tests, finishing with a polished app of your own that you can run on your phone.
- Dart
- Flutter widgets
- Mobile UI layout
Build data-driven Flutter apps the way professionals do: talk to web APIs, manage state with Provider, store data in SQLite, structure the code in layers, add sign-in and routing, and protect everything with automated tests.
- REST APIs in Flutter
- State management with Provider
- SQLite and offline cache
Take a Flutter app from working to production-grade: rendering performance, scalable architecture with Riverpod, an offline sync engine, platform integration, localisation and accessibility, and a signed, automated, monitored release.
- Flutter performance
- Riverpod and architecture
- Offline sync
Learn how neural networks learn by building them yourself in PyTorch: tensors, gradients, training loops, data pipelines, evaluation and convolutional networks, finishing with an image classifier you can explain and defend.
- PyTorch
- Neural networks
- Gradient descent
Build practical vision and language systems with pretrained models: transfer learning for images, object detection, text classification with transformers, efficient training and a served model with tests and a latency report.
- Transfer learning
- Computer vision
- Transformers and NLP
Engineer reliable applications on top of large language models: prompting and structured output, retrieval-augmented generation, evaluation harnesses, tool-using agents, security and red-teaming, and cost, latency and quality trade-offs in production.
- LLM application design
- Retrieval-augmented generation
- Evaluation harnesses
Learn C and how a computer really works: memory, pointers, bits and bytes, files, debugging with real tools and writing safe code, finishing with a command-line tool suite of your own.
- C programming
- Pointers and memory
- Data representation
Learn how an operating system works by using and building its pieces on Linux: processes and system calls, scheduling and threads, synchronisation, virtual memory, file systems and container isolation, with code and measurements.
- System calls
- Processes and threads
- Synchronisation
Build network servers from sockets up and understand them under load: TCP and TLS behaviour, event-driven servers with epoll, a safe HTTP implementation, performance methodology with profilers and tracing, and a measured, hardened network service.
- Socket programming
- epoll and event loops
- TCP/IP internals
Learn the habits of professional developers: Git and pull requests, readable code, automated tests with pytest, debugging, working with others and continuous integration, finishing with a small project released like real software.
- Git and GitHub
- Clean code
- Unit testing with pytest
Design software that is easy to change: test-driven development, SOLID design, the patterns that solve recurring problems, taming legacy code, and property-based and mutation testing, finishing with a well-designed, thoroughly tested application.
- Test-driven development
- SOLID design
- Design patterns
Learn to make and defend the decisions that shape software systems: architectural styles and trade-offs, domain-driven design, enforcing architecture with code, evolving and modernising systems, delivery metrics, incident reviews and the written communication that leads teams.
- Software architecture
- Domain-driven design
- Architecture decision records
Install Godot, learn nodes, scenes and GDScript, then build a catcher game and a platformer step by step, add sound, animation and menus, save the high score and export a game to share.
- Godot 4
- GDScript
- 2D game development
Move beyond tutorials by building reusable gameplay systems: typed GDScript and clean architecture, state machines, enemy AI with navigation, hitboxes and health components, data-driven items and inventory, UI and save systems, shaders for game feel and automated tests.
- Typed GDScript
- State machines
- Enemy AI and navigation
Engineer games at professional depth in Godot 4: engine internals and performance, authoritative multiplayer with prediction and interpolation, procedural generation, advanced AI, tooling and extensions, and the business of shipping, patching and supporting a game.
- Godot engine internals
- Multiplayer networking
- Procedural generation
Understand how blockchains really work by building one in Python: hashing, digital signatures, blocks, proof of work, wallets and transactions. Then learn Ethereum accounts and gas, deploy simple Solidity contracts with Remix to a test network and learn how to spot scams and risks.
- Blockchain concepts
- Hashing and digital signatures
- Python
Write production-style Solidity: storage, inheritance and custom errors, then test with Hardhat, build ERC-20, ERC-721 and staking contracts with OpenZeppelin, learn gas and design patterns, build a dApp front end with ethers.js and deploy and verify to a public test network.
- Solidity
- Hardhat
- OpenZeppelin
Learn how smart contracts are broken and how professionals defend them: vulnerability classes, Foundry fuzzing and invariant testing, DeFi mechanics and oracle attacks, upgradeability and cross-chain risk, static and formal analysis, and the audit process from scoping to a written report.
- Smart contract security
- Foundry fuzzing and invariants
- DeFi protocol analysis
Learn how electronics and microcontrollers work and program an Arduino in C++ to read buttons and sensors, drive LEDs, servos and displays, structure code without blocking, debug hardware and build a working device. No hardware is required to start, because everything can be built in a free online simulator.
- Arduino C++
- Basic electronics
- Sensors and actuators
Build connected devices with the ESP32: Wi-Fi, HTTP and JSON, a configurable web portal, MQTT messaging with last-will and retained messages, a time-series pipeline with Node-RED, InfluxDB and Grafana, battery-powered deep-sleep nodes and the security practices that keep IoT devices safe.
- ESP32
- Wi-Fi and HTTP
- MQTT
Engineer embedded firmware at professional depth: robust embedded C, FreeRTOS concurrency on ESP-IDF, peripheral drivers and DMA, host-side testing with hardware abstraction, real-time timing analysis and control, and secure boot, encrypted storage and safe over-the-air updates.
- Embedded C
- FreeRTOS and ESP-IDF
- Peripheral drivers and DMA
Learn modern Java from scratch: syntax, control flow, methods, object-oriented design with classes, interfaces and records, collections and streams, exceptions, files and automated tests with JUnit and Maven, finishing with a tested console application.
- Java syntax and the JVM
- Object-oriented design
- Collections and streams
Build production-style backends with Spring Boot 3: dependency injection and configuration, well-designed REST APIs with validation and error handling, JPA with PostgreSQL and migrations, authentication and authorisation with JWT, layered automated tests with Testcontainers, observability and Docker packaging.
- Spring Boot 3
- REST API design
- JPA and Hibernate
Design, build and operate distributed Java systems: service boundaries and data ownership, resilient synchronous calls, Kafka messaging with outbox and sagas, gateways and token-based security between services, metrics, traces and logs, JVM performance, contract testing and deployment to Kubernetes with CI/CD.
- Microservice architecture
- Resilience4j
- Apache Kafka with Spring
Learn Rust from scratch: Cargo, types and control flow, ownership and borrowing, structs and enums with pattern matching, collections, error handling, traits and generics, and unit testing, building two command-line tools and a final project.
- Rust syntax
- Ownership and borrowing
- Enums and pattern matching
Go beyond the basics: smart pointers, threads and channels, shared state without data races, async Rust with Tokio, and production-style web services with Axum, SQLx and PostgreSQL, tested, traced and packaged in containers.
- Smart pointers
- Threads and channels
- Async Rust and Tokio
Understand Rust at depth: the advanced type system and macros, writing sound unsafe abstractions and checking them with Miri, how async really works, calling and being called from C and Python, performance engineering with profilers and benchmarks, and Rust on WebAssembly and microcontrollers.
- Advanced traits and macros
- Unsafe Rust and soundness
- Async internals
Learn Go from scratch: tooling and modules, types, slices and maps, structs, methods and interfaces, error handling, goroutines and channels, testing and the standard library, building a file tool, a concurrent checker and a final project.
- Go syntax and tooling
- Slices, maps and structs
- Interfaces and errors
Build and operate real backend services in Go: project structure and dependency wiring, HTTP APIs with middleware, validation and errors, PostgreSQL with pgx and migrations, concurrency patterns for services, thorough testing with real databases, structured logs, metrics, profiling and containerised deployment.
- Go service architecture
- HTTP APIs and middleware
- PostgreSQL with pgx
Engineer distributed systems in Go: failure models and consistency, gRPC and Protocol Buffers with streaming and interceptors, event-driven messaging, replication and consensus with Raft, runtime and performance tuning, and Kubernetes controllers and operators built with controller-runtime.
- Distributed systems design
- gRPC and Protocol Buffers
- Event-driven messaging
Learn how websites work and build them properly: semantic HTML, modern CSS layout with Flexbox and Grid, responsive design, JavaScript and the DOM, asynchronous code with fetch, accessibility, DevTools and deployment, finishing with a polished multi-page project.
- Semantic HTML
- Modern CSS layout
- Responsive design
Build real applications with React and TypeScript: strict typing for frontend code, components and hooks, forms and state management, routing and server-state with TanStack Query, styling and accessible UI, automated tests with Vitest, Testing Library, MSW and Playwright, and performance fundamentals.
- TypeScript
- React and hooks
- State and forms
Design and run large frontend systems: rendering strategies and the Next.js App Router, caching and data mutation, monorepos and micro-frontends, a versioned design system, frontend security, main-thread performance engineering, real-user monitoring, offline-first and real-time collaboration.
- Rendering architecture
- Next.js App Router
- Monorepos and micro-frontends
Learn how data engineering works from the ground up: SQL for analytics, Python and pandas for wrangling, file formats, ETL pipeline design, dimensional modelling, data quality checks, scheduling and Git, using only free local tools (SQLite, DuckDB and PostgreSQL), and build a warehouse with a dashboard.
- SQL
- Python and pandas
- ETL design
Build production-style batch data platforms: ELT and lakehouse architecture, workflow orchestration with Apache Airflow, tested and documented SQL transformations with dbt, distributed processing with Apache Spark, data quality and observability, and warehouse performance and cost control.
- ELT and lakehouse design
- Apache Airflow
- dbt
Engineer real-time and large-scale data systems: event time, windows and state in stream processing, Kafka and change data capture, exactly-once pipelines, how Iceberg and Delta tables work internally, data contracts and schema evolution, privacy and deletion at scale, and reliability engineering for data platforms.
- Stream processing
- Kafka and CDC
- Lakehouse table formats
Learn how to test software properly: test thinking, test design techniques, writing test cases and bug reports, exploratory testing, test management in Agile teams, then automate checks for web pages and APIs with Python, pytest, Playwright and requests.
- Test design techniques
- Bug reporting
- Exploratory testing
Build and run professional automation: strategy and design for testability, a maintainable Playwright framework in TypeScript, API and contract testing with schemas and Pact, reliable test data and environments with Docker, performance testing with k6, accessibility and cross-browser checks and CI pipelines with quality gates.
- Automation architecture
- Playwright with TypeScript
- API and contract testing
Lead quality for large systems: risk-based strategy for organisations, eliminating flaky tests and building test infrastructure, testing distributed systems with contracts, chaos and production testing, security testing in the pipeline, advanced techniques such as property-based, mutation, model-based and metamorphic testing, testing data and machine learning systems, and measuring and growing a quality culture.
- Quality strategy and leadership
- Flaky test elimination and test infrastructure
- Chaos and resilience testing
Learn how programming languages work by building one: tokenising source text, parsing with recursive descent and Pratt precedence, building syntax trees, evaluating with environments, functions and closures, reporting good errors, testing the language and finishing with your own complete interpreter.
- Lexing
- Parsing and ASTs
- Interpreters
Build a real compiler: architecture of front, middle and back ends, symbol tables and static type checking with inference, a bytecode compiler and a stack virtual machine with calls and closures, intermediate representations and basic optimisations, memory management and garbage collection, and code generation to LLVM IR, WebAssembly or assembly.
- Compiler architecture
- Type checking and inference
- Bytecode virtual machines
Work at the level of production language implementations: dataflow and SSA optimisation, register allocation, LLVM and MLIR pass pipelines, just-in-time compilers with inline caches and deoptimisation, modern garbage collectors, debug information, language servers, and compiler testing with fuzzing and translation validation.
- SSA optimisation
- Register allocation
- LLVM and MLIR
Learn how computer graphics works by making things move on screen: drawing and animating on the 2D canvas, the vectors and matrices behind every transformation, the 3D pipeline, and building interactive 3D scenes with Three.js including lights, materials, textures and models.
- Canvas 2D
- Vectors and matrices
- Graphics pipeline
Go beneath the library: write vertex and fragment shaders in GLSL, create procedural effects with noise and signed distance functions, implement diffuse, specular, normal-mapped and shadowed lighting, understand physically based rendering and image-based lighting, and build post-processing and render-to-texture pipelines.
- GLSL shaders
- Procedural graphics
- Lighting models
Build renderers that solve the rendering equation: CPU path tracing with Monte Carlo integration, importance sampling and acceleration structures, then real-time engineering with WebGPU compute, GPU ray tracing concepts, virtualised geometry, global illumination, denoising and profiling.
- Path tracing and Monte Carlo methods
- Acceleration structures
- Importance sampling
No programme matches that.
Try fewer words, or clear the filters.