Track 01 · Cohort 03 · Starts 26 October 2026

Software Engineering + AI/ML Fellowship

A Master's-level engineering programme you can do around a job. You go from how a CPU runs your code, through safe systems programming in Rust and distributed consensus, to building and evaluating AI systems that hold up in production.

Length: 4 months · 17 teaching weeks
Weekly time: ~35 h: 4-5 h weekdays, longer weekends
Format: Live online, fully remote
Tuition: ₹0 upfront with ISA, or ₹2,00,000 + GST

Apply to this track See the curriculum

A developer workstation with code on several screens

What you'll be able to do

The engineer teams want: deep, fast and AI-fluent.

We designed the track backwards from the interviews and the first ninety days of strong engineering roles, then set the depth at the level of a good Master's programme.

Reason from the hardware up

Explain a performance problem in terms of caches, memory, syscalls and the network, then prove the fix with a benchmark.

Write safe, concurrent Rust

Own the borrow checker, design idiomatic APIs, write async services on tokio and wrap C safely through FFI.

Build distributed systems

Implement Raft, choose consistency models deliberately, and pass a system design interview at senior level.

Understand models, not just APIs

Train a small transformer from scratch, fine-tune with LoRA and explain what happens at inference time.

Ship AI systems that hold up

Build retrieval and agent systems with evaluation harnesses, guardrails, tracing and a cost budget.

Operate what you build

Deploy on Kubernetes with Terraform, set SLOs, threat-model your system and write a blameless postmortem.

Roles graduates prepare for

Backend EngineerFull-stack EngineerRust / Systems EngineerAI / ML EngineerApplied AI EngineerPlatform & SREFounding Engineer

Curriculum

Six modules. About 600 hours.

Each module has lectures, labs, a substantial project, readings and an assessment. Open any module to see the week-by-week detail.

Pre-workBefore 26 Oct
~40 h

Bridge: tools and foundations

Self-paced, so everyone starts week one on the same page.

Topics

Python and TypeScript refresher: types, functions, modules, async basics, testing.
Git and GitHub flow: branching, rebasing, pull requests, code review etiquette.
Linux and the shell: processes, files, pipes, ssh, make, editors.
Maths refresher: discrete maths, proof by induction, probability, linear algebra basics.
Complexity: Big-O, recurrences and why constant factors still matter.

Deliverable

Bridge checkpoint

A small CLI tool with tests and CI, submitted as a pull request. Used to place you in the Launch or Accelerate pod.

Module 1Weeks 1-3
26 Oct-15 Nov

Computer systems, algorithms and networks

How code actually runs, how to make it fast, and how machines talk.

Topics

Machine-level programs: data representation, x86-64 and ARM basics, how compilers, linkers and loaders work.
Memory: the memory hierarchy, caches and locality, virtual memory, paging, allocators.
Processes and threads: system calls, scheduling, signals, the cost of a context switch.
Concurrency primitives: mutexes, condition variables, atomics and memory ordering, lock-free basics.
Algorithms: amortised analysis, graph algorithms, dynamic programming, randomised algorithms.
Probabilistic data structures: Bloom filters, HyperLogLog, count-min sketch.
Networking: TCP and congestion control, HTTP/1.1 to HTTP/3 and QUIC, TLS 1.3, DNS.
Performance engineering: profiling with perf and flame graphs, honest benchmarking.

Labs and project

A concurrent HTTP server from sockets up

Thread pool, keep-alive and graceful shutdown, load-tested with wrk and written up as a performance report.

Bloom filter and LRU cache

Implement, benchmark and compare measured false-positive rates against theory.

Readings

Computer Systems: A Programmer's Perspective (Bryant, O'Hallaron), selected chapters · Introduction to Algorithms (Cormen et al.), selected · Computer Networking: A Top-Down Approach (Kurose, Ross), selected · What Every Programmer Should Know About Memory (Drepper)

Assessment

Timed problem set and a systems quiz.

Module 2Weeks 4-6
16 Nov-6 Dec

Rust, the Comprehensive Rust path

Modelled on the course Google's Android team uses, then taken further.

Week 4 · Rust Fundamentals I-II

Hello World and Cargo, types and values, control flow, tuples and arrays, references, user-defined types.
Pattern matching, methods and traits, generics, closures, standard library types and traits.

Week 5 · Fundamentals III-IV and Idiomatic Rust

Memory management, smart pointers (Box, Rc, RefCell, Arc), borrowing, lifetimes.
Iterators, modules, testing (unit, integration, doc and property tests), error handling.
Idiomatic Rust: foundations of API design, leveraging the type system (newtypes, typestate, builders), polymorphism.

Week 6 · Concurrency, async and unsafe

Threads, channels, Send and Sync, shared state, atomics.
Async basics, tokio, channels and control flow, async pitfalls and cancellation safety.
Unsafe Rust and FFI: raw pointers, safety invariants, bindgen and cxx interop, reviewing unsafe code.
Beyond the course: declarative and procedural macros.

Labs and project

Port the Module 1 server to async Rust

tokio and axum, compared with the original on latency, throughput and memory.

A safe wrapper over a C library

Generated bindings, a safe API with documented invariants, and fuzzing with cargo-fuzz.

Concurrent key-value store

A typed wire protocol, typestate connections and property-based tests.

Readings

Comprehensive Rust (Google) · The Rust Programming Language (Klabnik, Nichols) · Rust for Rustaceans (Gjengset) · Rust Atomics and Locks (Bos) · The Rustonomicon, selected

Assessment

A practical Rust exam covering ownership, traits and async, plus a code review of your lab.

Module 3Weeks 7-9
7-27 Dec

Full-stack and distributed systems

From a typed front end to consensus, with the database internals in between.

Topics

Front end: TypeScript in depth, React and Next.js, server components, accessibility, Core Web Vitals.
API design: REST, gRPC and GraphQL trade-offs, OAuth 2.0 and OIDC, idempotency, rate limiting.
Database internals: B-trees and LSM trees, indexing, query planning, transactions, isolation levels, MVCC.
Postgres in production: EXPLAIN, partitioning, replication, migrations without downtime.
Messaging: caching with Redis, queues and streams with Kafka, the outbox pattern.
Distributed systems: failure models, logical and hybrid clocks, replication, consistency models from linearisability to eventual.
Consensus and partitioning: Raft, Paxos intuition, consistent hashing, CAP and PACELC.
System design practice: design reviews of real architectures, every Saturday.

Labs and project

Raft in Rust

Leader election, log replication and persistence against a deterministic test harness, then a replicated key-value store on top.

A full-stack product slice

Next.js front end, Rust or Node API, Postgres, authentication, tests and CI.

Readings

Designing Data-Intensive Applications (Kleppmann) · In Search of an Understandable Consensus Algorithm (Ongaro, Ousterhout) · Dynamo (DeCandia et al.) · MapReduce (Dean, Ghemawat) · Spanner (Corbett et al.), optional

Assessment

A panel system design interview, and your Raft implementation passing the test suite.

Module 4Weeks 10-13
4-31 Jan

AI and machine learning engineering

The maths, the models and the systems around them.

Week 10 · Foundations

Linear algebra, probability and optimisation for ML; bias and variance, regularisation, evaluation and cross-validation.
Classical ML: linear and logistic regression, trees and gradient boosting, feature engineering with scikit-learn.

Week 11 · Deep learning

Backpropagation from scratch with a tiny autograd engine, then PyTorch.
MLPs, CNN basics, embeddings, training dynamics, GPUs and mixed precision.

Week 12 · Transformers and LLMs

Tokenisation, attention and the transformer, pre-training objectives, scaling intuition.
Fine-tuning with SFT and LoRA, preference tuning, inference with KV caches, batching, quantisation and speculative decoding.

Week 13 · Applied AI systems

Embeddings and vector search, retrieval-augmented generation, structured output and tool use, agents and MCP.
Evaluation, guardrails and prompt-injection defence, MLOps, monitoring and drift, responsible AI under India's DPDP Act.

Labs and project

A small GPT, from scratch

Train a character- or BPE-level transformer in PyTorch on a public corpus, measure perplexity and run ablations.

A production RAG and agent service

Ingestion, hybrid search, tool calls, a golden-set evaluation harness, tracing and a cost dashboard, served behind an API.

Tabular ML done properly

Leakage-free validation and a model card for a real dataset.

Readings

Deep Learning (Goodfellow, Bengio, Courville), selected · Attention Is All You Need (Vaswani et al.) · LoRA (Hu et al.) · Retrieval-Augmented Generation (Lewis et al.) · Designing Machine Learning Systems (Huyen)

Assessment

An ML theory exam, and an evaluation report you defend in review.

Module 5Weeks 14-15
1-14 Feb

Production engineering, security and AI-assisted development

Running systems for real, and working well with coding agents.

Topics

Infrastructure: containers, Kubernetes, Terraform, CI/CD and progressive delivery.
Observability: logs, metrics and traces with OpenTelemetry, SLOs and error budgets.
Reliability: incident response, on-call hygiene, blameless postmortems.
Security engineering: threat modelling, the OWASP Top 10 and the OWASP Top 10 for LLM applications, secrets, supply chain.
AI-assisted engineering: specification-first work with coding agents, reviewing generated code, test-driven verification, and when not to use them.
Practice: design docs, code review, estimation and async collaboration.

Labs and project

Operational readiness

Deploy your capstone skeleton with Terraform and CI/CD, add dashboards and alerts, run a game day and write the postmortem.

Break your own AI service

Threat-model and pen-test the Module 4 service, then fix and re-test.

Readings

Site Reliability Engineering (Beyer et al.), selected · Building Secure and Reliable Systems, selected · OWASP Top 10 for LLM Applications

Assessment

An operational readiness review with a senior engineer.

Module 6Weeks 16-17
15-26 Feb

Capstone, hiring sprint and Demo Day

Build something real, defend it, and start interviewing.

What happens

Capstone: solo or in a team of two or three, a production-grade system with a meaningful AI component and at least one Rust service. Briefs come from hiring partners where available.
Panel defence: architecture, trade-offs, failure modes and cost, in front of senior engineers.
Hiring sprint: profile and CV review, mock coding, system design and behavioural interviews, then facilitated interviews with partners.
Demo Day: Friday 26 February 2027.

Capstone requirements

The bar

A design doc, tests, CI, observability, an evaluation harness for the AI component, a cost estimate and a recorded demo.

The Rust module

Rust, taught the way Google teaches it.

Comprehensive Rust is a free course developed by the Android team at Google: four days of Rust Fundamentals followed by deep dives on concurrency, idiomatic Rust, unsafe code and bare-metal work. Our Module 2 follows that structure closely, spreads it over three weeks so it actually sticks, and adds graded labs. Then we keep using Rust in Modules 3 to 6.

Comprehensive Rust segment	Where it sits	What we add
Day 1: Hello World, types and values, control flow, tuples and arrays, references, user-defined types	Week 4 · Mon-Tue	Auto-graded exercises, compared against the C memory model from Module 1
Day 2: pattern matching, methods and traits, generics, closures, standard library types and traits	Week 4 · Wed-Sun	Lab: a typed protocol parser
Day 3: memory management, smart pointers, borrowing, lifetimes	Week 5 · Mon-Wed	Borrow-checker clinic; graph structures with `Rc` and `Weak`
Day 4: iterators, modules, testing, error handling, unsafe Rust	Week 5 · Thu-Fri	Property-based testing and fuzzing
Deep dive: Idiomatic Rust (API design, the type system, polymorphism)	Week 5 · weekend	Typestate and newtype patterns in the key-value store
Deep dive: Concurrency (threads, channels, Send and Sync, shared state, async, pitfalls)	Week 6	Porting the HTTP server to tokio and measuring it
Deep dive: Unsafe Rust, and C/C++ interop as used in Android and Chromium	Week 6	A bindgen or cxx wrapper, with fuzzing and a safety review
Deep dive: Bare-metal Rust	Elective	`no_std` firmware on an emulated board
Beyond the course: macros, Raft in Rust, a Rust inference or API service	Modules 3-6	Rust used again and again, not learned once

Engagetal is not affiliated with or endorsed by Google. Comprehensive Rust is published by Google as a free, openly licensed course; our module follows its structure and adds our own teaching, labs and assessment.

AI/ML across the track

Not a bolt-on. AI runs through everything.

Module 4 is four dedicated weeks of AI and ML engineering. But AI shows up in every module, because it shows up in every engineering job.

Module 1: profiling model inference and understanding why memory bandwidth matters for LLMs.
Module 2: a Rust service that calls a model with typed, validated outputs.
Module 3: vector search inside Postgres, and designing for AI workloads.
Module 5: the OWASP LLM Top 10, evaluation in CI and working with coding agents.
Capstone: every project ships an AI component with an evaluation harness.

An illustration of a circuit board shaped like a brain

A week in Module 2

What week 5 actually looks like.

Day	Live (7:30-9:30 pm IST)	Guided practice
Mon	Memory management: stack and heap, ownership and moves, `Drop`	Exercises: ownership puzzles; read Rust for Rustaceans ch. 1
Tue	Smart pointers: `Box`, `Rc`, `RefCell`, `Arc`	Build a doubly linked list three ways and explain the trade-offs
Wed	Borrowing and lifetimes	Borrow-checker clinic problems; fix five failing programs
Thu	Iterators, modules and testing	Refactor the protocol parser into a crate with tests
Fri	Error handling and a review of the week	Catch-up and reading
Sat	Lab day: Idiomatic Rust workshop (newtypes, typestate, builders), then pair-build the key-value store, then code review in pods
Sun	Build sprint on the key-value store, and the weekly assessment on ownership and lifetimes

Assessment and certification

A certificate that means you can do it.

You graduate by meeting the bar, not by attending. Everything is marked against published rubrics, and you get written feedback on every project.

At least 80% attendance at live sessions.
Every module project submitted and passing review.
A pass in the module assessments, with one resit allowed per module.
A successful capstone defence. Distinction for the strongest.

40%Module projects

25%Capstone and defence

20%Weekly assessments

15%Module exams

Prerequisites. A completed bachelor's degree in any discipline, and the ability to write working programs in at least one language. The admissions exercise checks this. No prior Rust or ML experience is needed.

Tools you'll use

The stack of a modern engineering team.

RusttokioaxumPythonTypeScriptCReactNext.jsPostgreSQLpgvectorRedisKafkaPyTorchscikit-learnHugging FacevLLMDockerKubernetesTerraformGitHub ActionsOpenTelemetryGrafanaperfcargo-fuzzClaude CodeCursor

Track FAQ

About the engineering track.

I don't have a computer science degree. Can I apply?

Yes. Any completed bachelor's degree qualifies, as long as you can already write working code. Many strong engineers studied something else. The admissions exercise and the pre-work are how we make sure you are ready.

Why Rust, and not just Python and JavaScript?

Because learning Rust properly forces you to understand memory, ownership and concurrency, which makes you better in every language. It is also increasingly used for infrastructure, security-sensitive code and AI serving. We still teach Python and TypeScript, and use them where they are the right tool. Our founder wrote about this in Why we teach Rust the way Google does.

Is this really Master's level?

In depth, yes: you implement consensus, train a transformer from scratch and read primary research papers. It is not an academic degree and does not award academic credit. It is designed for people who want graduate-level skill without two years out of work.

How much maths do I need?

School-level algebra and a willingness to work. The pre-work refreshes discrete maths, probability and linear algebra, and Week 10 rebuilds what you need for ML from the ground up.

Can I use AI tools during the programme?

Yes, and we teach you to use them well. Some exercises and exams are deliberately done without them, so you build the understanding needed to judge what they produce.

Cohort 03 · starts 26 October 2026

Four months from now, you could be interviewing at a different level.

Part-time and fully remote, so you keep your job while you train. Pay ₹0 upfront with the Income Share Agreement, and nothing at all unless we place you.

Apply for Cohort 03 How the ISA works