Detailed Class Planning Standards 6 through 12

HTML structures. CSS styles. JavaScript does everything else — logic, animation, data fetching, user interaction. It's the only language browsers can execute directly (without plugins or compilation). Every interactive thing you've ever seen on a website — Google's autocomplete, YouTube's like button, Instagram's infinite scroll — is JavaScript. No other language comes close to its ubiquity in the browser.

JavaScript has 7 primitive types: string, number, boolean, null, undefined, symbol, BigInt. Unlike Java or C++, you don't declare the type — JS infers it. This enables type coercion: "2" + 2 = "22" (string concatenation wins), "2" * 3 = 6 (multiplication converts string to number). This surprises every beginner. Use === (strict equality) instead of == to avoid type coercion bugs. This is the source of more JavaScript bugs than anything else.

The DOM (Document Object Model) is a tree of JavaScript objects that the browser creates from your HTML. Every element, attribute, and text node is a JavaScript object you can modify. document.querySelector('#btn').textContent = 'Clicked!' changes the button text live. document.createElement('div') adds a new element. This is why React works: it modifies the DOM efficiently instead of reloading the page.

Every interaction generates an event: click, keydown, scroll, submit, load. addEventListener('click', handler) registers a function to call when the event fires. The browser maintains an event queue — a list of pending events. The JavaScript event loop processes them one at a time. This single-threaded, event-driven model is why JavaScript feels responsive but can freeze if you run a long synchronous computation.

Arrays store ordered lists. map() transforms every element (double all numbers), filter() selects elements matching a condition (only numbers > 5), reduce() collapses an array to a single value (sum all numbers). These three methods — map, filter, reduce — come from functional programming and can replace most for loops. React renders lists using .map(). Every modern JS codebase uses them constantly.

Functions prevent repetition. Scope: variables inside a function don't exist outside (local scope). Variables outside a function can be accessed inside (closure). Arrow functions (=>) are shorter syntax but also change what 'this' refers to. Higher-order functions accept other functions as arguments — this is what makes addEventListener work (you pass a handler function to it).

@keyframes defines animation steps. animation property applies it. transition: all 0.3s ease makes property changes smooth. JavaScript can trigger animations by adding/removing CSS classes. This is how every modern UI feels smooth — the button scaling on hover, the menu sliding in. Performance tip: animate only transform and opacity (GPU-accelerated), not width or top (causes layout recalculation).

localStorage stores key-value pairs in the browser, persisting between sessions (max 5MB). sessionStorage clears when tab closes. Every website that "remembers" your dark mode preference, shopping cart, or form draft uses localStorage. It's synchronous (blocks the main thread), so don't store large data. JSON.stringify() converts objects to strings for storage; JSON.parse() converts back.

Before Flexbox (pre-2012), centering a div vertically required float hacks, negative margins, or absolute positioning tricks. display: flex makes the container a flex container; justify-content: center centers horizontally; align-items: center centers vertically. flex-direction: column changes from row to column layout. Instagram's photo grid, Gmail's sidebar, and every modern navigation bar uses Flexbox.

This capstone applies: arrays (store questions), DOM manipulation (update question display), events (handle answer clicks), CSS animations (result feedback), localStorage (persist high score), functions (calculate score). Students write 150+ lines of real, working JavaScript — the largest program they've written so far. The goal: every part you understand means you can rebuild it from memory.

Digital signals are discrete: 0V or 5V, nothing between. Analog signals are continuous: any value between 0V and 5V. Real-world phenomena — temperature, light, sound, pressure — are analog. Arduino's ADC (Analog-to-Digital Converter) samples the analog pin 10,000 times per second and maps 0V–5V to the numbers 0–1023. That's 10-bit resolution. Professional audio ADCs use 24-bit — 16 million levels instead of 1024.

An LDR is a photoresistor: its resistance decreases as light intensity increases. In bright light: ~1kΩ resistance → more current → higher analogRead value (~900). In darkness: ~1MΩ resistance → barely any current → low analogRead value (~50). Combined with a fixed resistor as a voltage divider, this creates a measurable analog signal. Automatic street lights have used LDRs since the 1960s — they turn on when the LDR resistance rises (darkness) and trigger a relay.

A potentiometer is just a resistor with a sliding contact. Turning the knob moves the contact, changing what fraction of the total resistance you see at the output pin. map(analogRead(A0), 0, 1023, 0, 180) converts the 0–1023 ADC value to 0–180 degrees for servo control. Volume knobs, old TV channel selectors, and car stereo balance controls were all potentiometers.

Serial.begin(9600) opens a communication channel at 9600 bits/second. Serial.println(value) sends data to the Arduino IDE's Serial Monitor. This is how you debug: print sensor values, variable states, and decision points. Professional embedded engineers use the same technique — they call it "UART debug logging." Without Serial output, debugging a microcontroller program is like debugging software blindfolded.

DHT11 uses a capacitive humidity sensor and a thermistor. A single-wire protocol sends 40-bit data packets (humidity integer + decimal + temperature integer + decimal + checksum). Accuracy: ±2°C, ±5% humidity, samples every 2 seconds (faster will cause errors). DHT22 is more accurate (±0.5°C) and costs 3× more — the classic accuracy vs cost tradeoff. This same tradeoff exists in industrial sensors costing ₹5,000 vs ₹50,000.

A servo motor contains a DC motor, gearbox, and feedback potentiometer. The control circuit compares the target angle to the current angle and drives the motor to close the difference. This is closed-loop feedback control — a concept that also controls aircraft autopilots, CNC machines, and robot arms. Servo.write(90) sends a 1.5ms PWM pulse to position the horn at 90°. The 50Hz PWM signal is the industry standard for RC servos.

I2C (Inter-Integrated Circuit) is a protocol where one master device (Arduino) talks to many slave devices (LCD, sensors, OLED) on just 2 wires: SDA (data) and SCL (clock). Each device has a unique 7-bit address (the LCD is usually 0x27 or 0x3F). The master sends the address first; only the matching slave responds. This is how a single Arduino can control up to 128 different devices simultaneously.

The HC-SR04 sends 8 ultrasonic pulses at 40kHz, then measures the time for the echo to return. Distance = (echo_time_microseconds × 0.0343cm/μs) / 2. The /2 is because the sound travels to the object AND back. Sound travels 343m/s at 20°C — this changes with temperature, which is why precision ultrasonic rangefinders include a temperature correction. Range: 2cm to 400cm. Accuracy: ±3mm. Car parking sensors use the same principle.

LDR reads light level → analogRead() returns 0–1023 → map() converts to 0–255 → analogWrite() sets LED brightness inversely. When it's dark (LDR value low), LED shines bright. When it's bright, LED dims. This is a closed-loop feedback system: sensor reads environment → microcontroller processes → actuator responds. This same architecture controls aircraft autopilots, rocket stabilization, and climate control systems.

Python was created by Guido van Rossum in 1991, named after Monty Python (not the snake). The design philosophy: "There should be one — and preferably only one — obvious way to do it." Python code reads like English: if temperature > 100: print("boiling"). This clarity is why scientists, researchers, and data analysts choose Python over C or Java. It's the #1 language in Stack Overflow's 2024 Developer Survey. NASA, CERN, Instagram, and Spotify all use Python extensively.

Python is dynamically typed: x = 5 (integer), x = "hello" (string), x = 3.14 (float) — same variable, different types, Python tracks it automatically. Unlike Java where you write int x = 5, Python infers. This flexibility speeds development but can cause bugs: accidentally treating a string as a number raises a TypeError instead of silently computing wrong results.

Lists are ordered, mutable sequences: [1, 2, 3]. Dictionaries are key-value mappings: {"name": "Ravi", "age": 13}. Python's list comprehensions — [x*2 for x in range(10)] — create lists in one elegant line. Under the hood, Python lists are dynamic arrays (like Java's ArrayList). Dictionaries use hash tables — O(1) average lookup time — which is why checking if a key exists in a dict is faster than searching a list.

Every large Python codebase is built from functions. def calculate_bmi(weight, height): return weight / (height**2). Functions eliminate copy-paste code. Default parameters: def greet(name, greeting="Hello") allows calling greet("Ravi") or greet("Ravi", "Namaste"). *args and **kwargs accept variable numbers of arguments — used everywhere in library code.

pandas was created by Wes McKinney at AQR Capital Management in 2008 for financial data analysis. A DataFrame is a 2D table (rows × columns) — like a supercharged spreadsheet that can handle millions of rows in memory. df.describe() shows count, mean, std, min, quartiles, max in one call. df.dropna() removes missing values. df.groupby('team').sum() aggregates by group. These operations that take minutes in Excel take milliseconds in pandas.

matplotlib was modelled after MATLAB and released in 2003. plt.plot(x, y) for line charts, plt.bar(categories, values) for bar charts, plt.scatter(x, y) for scatter plots. Unlike Excel charts, matplotlib charts are code — you can reproduce them exactly, version-control them in Git, and generate thousands of charts automatically. The entire scientific publishing workflow uses matplotlib for paper figures.

Real datasets are messy. df.isnull().sum() counts missing values per column. df.fillna(df.mean()) replaces NaN with column averages. df['name'].str.strip().str.lower() standardises text. Duplicate rows: df.drop_duplicates(). Data cleaning typically takes 60–80% of a data scientist's time. The IPL dataset students use has inconsistent team names ("Mumbai Indians", "MI", "Mumbai") — cleaning these is the first real task.

df.groupby('team')['runs'].mean() calculates average runs per team in one line. Under the hood: split data into groups → apply aggregation function → combine results. This split-apply-combine pattern is at the heart of data analysis and the reason SQL's GROUP BY exists. The IPL question "which team wins most often at Wankhede?" is answered with .groupby(['team','venue'])['result'].count().

df.corr() computes Pearson correlation coefficients. Range: -1 to +1. +1 = perfect positive relationship. 0 = no linear relationship. -1 = perfect inverse. BUT: correlation ≠ causation. Ice cream sales correlate with drowning deaths — both increase in summer. The real cause is hot weather. This distinction is the most important concept in statistics. Every misleading news headline about data confuses correlation with causation.

A class is a blueprint; an object is an instance. class Car: defines wheels, engine, speed. car1 = Car() creates one specific car. Every video game character, every bank account, every user profile in every app is an object. OOP's four pillars: Encapsulation (hide internal details), Inheritance (child class gets parent's properties), Polymorphism (same method, different behaviour), Abstraction (expose only what's needed). Instagram's "Post" class has attributes (image, caption, likes) and methods (like(), comment(), share()).

class AdminUser(User): inherits all User methods and adds ban_user(). The child class can override parent methods: User.greet() says "Hello", AdminUser.greet() says "Hello, Admin." super() calls the parent class method from within the child. Python supports multiple inheritance (class C(A, B):) — powerful but dangerous. Django's class-based views use this heavily: ListView, DetailView, and CreateView all inherit from a base View class.

Django = Model (database schema and access layer) + View (business logic) + Template (HTML generation). A request hits urls.py → routed to a View function → View queries the Model → Model returns data → View renders a Template with the data → HTTP response sent back. This separation means: your database structure doesn't need to match your HTML structure. Django was built at Lawrence Journal-World newspaper (2003) to build web apps at "newspaper speed" — fast iteration, tight deadlines.

Instead of writing SELECT * FROM users WHERE age >= 18, you write User.objects.filter(age__gte=18). Django generates optimised SQL. More examples: Post.objects.all() → SELECT * FROM posts. Post.objects.create(title="Hello") → INSERT INTO posts... Post.objects.filter(author=user) → SELECT WHERE author_id=..., then a JOIN. The double underscore (__) in filter() is Django's field lookup syntax — age__gte means "age greater than or equal to."

You define your database schema in Python: class Post(models.Model): title = models.CharField(max_length=200). Then python manage.py makemigrations generates SQL. python manage.py migrate applies it. Migrations are version-controlled database changes — you can roll back a bad schema change. This is revolutionary: your database schema lives in code, tracked in Git, with full history. Before Django, schema changes were manual SQL scripts with high risk of error.

{% extends "base.html" %} makes a template inherit from a parent. {% block content %} defines a replaceable region. Child templates only override specific blocks — the header, footer, and navigation are in base.html once. {% for post in posts %} iterates over a QuerySet. {{ post.title }} renders a variable. This is the Jinja2 syntax (Jinja2 was inspired by Django's template engine). Every major web framework has an equivalent: Blade (Laravel), EJS (Node), Thymeleaf (Java).

Django provides authentication out of the box: User model, login/logout views, @login_required decorator. Passwords are hashed with PBKDF2 (salted SHA256) before storage — never stored in plain text. A salt is a random string added before hashing so identical passwords have different hashes (defeats rainbow table attacks). This is why "Forgot Password" always resets your password — the site can't recover the original because it doesn't know it.

python manage.py createsuperuser creates an admin account. Visit /admin/ — Django generates a full CRUD interface for every registered model. No code required. Filter, search, bulk-edit, custom actions. Instagram's early content moderation team used Django admin to review reported posts. Most startups use it internally for 2–3 years before needing a custom admin panel. Register your model with @admin.register(Post) and specify list_display = ['title', 'author', 'created_at'].

image = models.ImageField(upload_to='posts/') handles file uploads. MEDIA_ROOT specifies the server directory. Never store uploaded files in your codebase — use separate media storage (AWS S3, Cloudinary) in production. Image validation: check file extension AND magic bytes (the first 4 bytes of a file that identify its type) — users can rename .exe files to .jpg. Django's form validation handles this if you use ImageField with Pillow installed.

PythonAnywhere provides free Python web hosting. You upload your project, configure a WSGI file (Web Server Gateway Interface — the standard interface between Python web apps and web servers), and set your domain. Production differences: DEBUG = False, ALLOWED_HOSTS set, static files served separately (python manage.py collectstatic), database moved from SQLite to PostgreSQL for reliability. Every deployment teaches a lesson no tutorial can.

Arduino's digital pins output 5V at maximum 40mA. A DC motor draws 250mA–2A. If you connect a motor directly to Arduino, you'll pull too much current, drop voltage on the 5V rail, and crash the processor (or burn it). The L298N is an H-bridge circuit: 4 transistor switches that let a small control signal (from Arduino) switch a separate high-current supply (motor battery) to the motor. It can source up to 2A continuously. This is the same principle Tesla uses: a 12V signal controls a 400V, 300A motor controller.

OLED (Organic LED) pixels emit their own light — no backlight needed, so blacks are truly black (pixel off = no light). The SSD1306 OLED driver chip handles a 128×64 pixel buffer. You write to the buffer in Arduino memory, then flush to the display over I2C (100kHz) or SPI (8MHz — much faster). The Adafruit GFX library provides drawText(), drawBitmap(), drawLine(). Understanding framebuffers here is the same concept used in game rendering and GPU programming.

The SD library uses SPI communication to write FAT32-formatted files to an SD card. SD.begin(chipSelectPin) mounts the filesystem. File f = SD.open("data.csv", FILE_WRITE) opens a file. f.println(timestamp + "," + temperature) writes a CSV row. This is how black boxes on aircraft record flight data — the same FAT32 filesystem, the same SPI-connected flash storage, just with aerospace-grade shock and fire resistance.

Phase 1 (Bang-Bang): if leftmost IR sensor → turn hard right; if rightmost → turn hard left. Simple but oscillates violently. Phase 2 (Proportional): error = (sum of weighted sensor positions). motorSpeed += Kp * error. Kp is a tuning constant — too high and it oscillates, too low and it responds sluggishly. This P-control is the foundation of PID control used in every precision system. Students experience empirically why Kp matters — a hands-on introduction to control theory taught in 4th-year engineering courses.

Resistive sensors measure conductivity by passing current through soil — they corrode within weeks due to electrolysis. Capacitive sensors measure the dielectric constant of soil (how much it resists forming an electric field) — no current flows through the soil, so no corrosion. Fully wet soil has dielectric constant ~80. Dry soil has ~3. The sensor outputs a voltage proportional to capacitance. Better accuracy, longer lifespan. Used in commercial smart irrigation systems (Israel's precision irrigation technology uses this in the Negev Desert).

A relay is an electrically operated switch: a small coil creates a magnetic field that closes a mechanical contact. The optocoupler provides electrical isolation between the Arduino (5V logic circuit) and the relay coil (potentially higher voltage), preventing voltage spikes from damaging the microcontroller. This is the same principle used in industrial PLC (Programmable Logic Controller) systems that switch factory machinery from computer signals.

Capacitive soil sensor reads moisture (0–1023 ADC) → mapped to 0–100% → if below threshold: open relay (water pump on) for 3 seconds → re-check moisture → repeat. DS3231 RTC chip maintains accurate time even with power cuts (has its own coin cell battery). Timestamps every watering event to SD card. OLED shows: current moisture, last-watered time, pump status. This is a complete closed-loop embedded system — the same architecture as industrial irrigation controllers costing ₹50,000.

Students race their line-following robots on a standard PREKSHA track: 2m straight, S-bend, 90° turns, T-junction (robot must choose correct branch). Fastest lap wins. This competition format is used in international robotics competitions (Robocon, WRO). The variables: IR sensor threshold calibration, Kp tuning, motor speed limits. Students learn that the "best" algorithm still fails with poor calibration. Software correctness + hardware calibration = actual performance.

Traditional programming: programmer writes rules → computer follows rules → output. Machine learning: programmer feeds examples (data + correct answers) → algorithm finds patterns → rules emerge automatically. Example: to write a spam filter with explicit rules, you'd list thousands of spam phrases. With ML, you feed 10,000 labelled emails (spam/not spam) and the algorithm extracts the patterns itself. The rules it finds are often too complex for a human to write explicitly — 50,000 features influencing the decision.

Supervised: every training example has a label (email → spam/not spam, photo → dog/cat, patient data → disease/no disease). The model learns to predict the label from features. Unsupervised: no labels — the model finds structure itself. K-means clustering finds groups of similar data points without being told what the groups are. Amazon's customer segmentation (which customers are similar enough to target together) is unsupervised clustering. Your school subject rankings are supervised — you label which scores are good/bad.

from sklearn.model_selection import train_test_split. Typically 80% train, 20% test. The model never sees test data during training. Why? A model that memorised training data would score 100% on training data but fail on new data — it learned patterns specific to those examples, not general rules. This is overfitting. Testing on held-out data measures real-world performance. It's like the difference between practising with the question paper and writing the actual exam.

y = mx + b, but generalised to multiple features: y = w1x1 + w2x2 + ... + b. Training finds the weights (w) that minimise the sum of squared errors — the distance between predicted and actual values. For predicting exam score from study hours: every extra hour of study increases score by w1 points (the weight). Coefficients are interpretable — you can explain exactly why the model made a prediction. This interpretability makes linear regression still widely used in medicine, economics, and policy despite being 200 years old (least squares method was invented by Gauss in 1795).

A decision tree splits data at each node based on the feature that best separates the classes. "Is study_hours > 5?" → Yes branch → "Is attendance > 80%?" → class: Pass. The tree is interpretable — you can follow the path from root to leaf and understand why a prediction was made. Random Forest is 100–500 decision trees trained on random subsets of data — their votes are averaged. More accurate than one tree, less interpretable. Used in loan approval, medical diagnosis, fraud detection.

Accuracy = correct / total. But: a model that always predicts "not fraud" on a 99% not-fraud dataset has 99% accuracy but misses every fraud! This is the accuracy paradox. Confusion matrix: True Positive (correctly predicted fraud), False Positive (predicted fraud but wasn't), True Negative (correctly predicted not fraud), False Negative (predicted not fraud but was fraud). Precision = TP/(TP+FP). Recall = TP/(TP+FN). F1 = harmonic mean of precision and recall. In medical diagnosis, recall (catching all actual cases) often matters more than precision.

Raw data rarely works directly with ML algorithms. Categorical variables (city names) must be one-hot encoded (a column per city, 0 or 1). Numerical features must be scaled (StandardScaler: mean=0, std=1) so features with large ranges don't dominate. Missing values filled (imputation). Date features decomposed into day_of_week, month, is_weekend. A well-engineered dataset with a simple model often outperforms a raw dataset with a complex model. 80% of a data scientist's work is feature engineering.

import gradio as gr. gr.Interface(fn=predict, inputs=["number","number"], outputs="text").launch() creates a web UI around your trained model. The user fills in study hours and attendance — your model predicts the exam score. Gradio hosts the app at a public URL instantly. This is the pipeline: collect data → train model → evaluate → deploy. Students experience the full ML workflow before any deep learning concepts are introduced.

In 2009 Ryan Dahl was watching a file-upload progress bar on Flickr. The server was blocked — doing nothing while waiting for the disk to write. Traditional servers spawned one OS thread per connection: 10,000 users = 10,000 threads = server out of RAM. Node.js uses a single thread with an event loop. When waiting for a database query, the event loop switches to handle 100 other requests instead of blocking. It's not multi-threaded — it's smarter about not waiting. LinkedIn rebuilt their mobile backend in Node.js in 2011: servers dropped from 30 to 3, handling 20× more traffic at lower cost.

REST (Representational State Transfer) was defined by Roy Fielding in his 2000 PhD dissertation — not as a technology but as an architectural style. Six constraints: stateless (no server memory between requests), uniform interface (standard HTTP methods), client-server separation, cacheable, layered system, code on demand. In practice: GET /api/tasks retrieves all. POST /api/tasks creates one. PUT /api/tasks/:id replaces. PATCH /api/tasks/:id partially updates. DELETE /api/tasks/:id removes. HTTP status codes are semantically meaningful: 200 OK, 201 Created, 400 Bad Request, 401 Unauthorized, 403 Forbidden, 404 Not Found, 409 Conflict, 500 Server Error. Using the wrong code (returning 200 for an error) breaks every client that relies on standard behaviour.

Express doesn't come with authentication, logging, CORS handling, or rate limiting. It comes with one concept: middleware. app.use(fn) adds a function to the request processing chain. Each middleware receives (req, res, next) and either handles the request or calls next() to pass it to the next middleware. Morgan logs requests: app.use(morgan('combined')). Helmet adds security headers: app.use(helmet()). Every Express app is a pipeline of middleware functions. Understanding this makes reading any Express codebase trivial — find what's in app.use() and you understand the entire request processing chain.

MongoDB stores JSON-like documents: {"name":"Ravi","posts":[{"id":1,"title":"Hello","published":true}]}. No fixed schema — add fields to some documents without migrating the entire database. Horizontal scaling: add more servers to distribute data (sharding). SQL databases use tables with fixed schemas, foreign keys, and JOIN operations for relationships. Rule of thumb: SQL for financial transactions, complex relationships, and data requiring strict ACID guarantees (banking, inventory). MongoDB for flexible, nested, rapidly-changing data (social media posts, user profiles, product catalogs with varying attributes). Many applications use both: MongoDB for flexible product data, PostgreSQL for orders and payments.

MongoDB has no schema by default — you can insert any JSON. But production apps need validation. Mongoose adds schemas on top: const taskSchema = new Schema({title:{type:String,required:true,maxLength:200},priority:{type:String,enum:['low','medium','high'],default:'medium'},dueDate:{type:Date}}). Now MongoDB enforces your rules before saving — invalid data throws a ValidationError before hitting the database. Mongoose also provides: query helpers (Task.findById()), virtual fields (fullName computed from firstName+lastName, never stored), pre/post hooks (hash password before saving), and populate() for joining documents. Used in almost every Node.js/MongoDB production app worldwide.

app.use(helmet()) adds 12 security headers in one line: Content-Security-Policy prevents XSS injection, X-Frame-Options prevents clickjacking, Strict-Transport-Security forces HTTPS. CORS: Cross-Origin Resource Sharing controls which domains can call your API. Without CORS configuration, your React app at localhost:3000 can't call your API at localhost:5000 — browsers block it. Rate limiting: app.use(rateLimit({windowMs:15*60*1000,max:100})) allows 100 requests per 15 minutes per IP — prevents API abuse and DDoS. These three middleware layers take 10 minutes to add and protect against 80% of common web attacks.

Postman is the standard tool for API development and testing across the industry. Set HTTP method, URL, headers (Authorization: Bearer {{token}}), JSON body. Environments store variables ({{baseUrl}}, {{token}}) — switch from localhost to production in one click. Collections organise requests by resource. Test scripts run automatically: pm.test("Status 201",()=>pm.response.to.have.status(201)); pm.test("Has ID",()=>pm.expect(pm.response.json().id).to.exist). Chain requests: extract the token from the login response and automatically set it as the {{token}} variable for subsequent requests. Students write 18 test cases covering all success paths and error paths (invalid token, missing field, duplicate entry, non-existent resource ID).

Render.com hosts Node.js apps for free. MongoDB Atlas provides cloud MongoDB with free 512MB clusters. Deployment: connect GitHub repo → Render detects Node.js → runs npm install → starts server. Environment variables (MONGODB_URI, JWT_SECRET, ALLOWED_ORIGIN) set in Render's dashboard — never in code, never in Git. Production differences from local: DEBUG=false, no stack traces in error responses, rate limiting enforced, CORS restricted to your actual frontend domain. The first deployment invariably fails — a missing environment variable, a hardcoded localhost URL, a case-sensitive filename issue on Linux. These failures teach more than any tutorial. Fixing them cements the distinction between "it works on my machine" and production engineering.

A deployed API without documentation is useless to others. README.md includes: base URL, authentication instructions, endpoint table (Method, Path, Description, Auth required), request/response examples for each endpoint, error codes reference. Optional: generate OpenAPI/Swagger spec automatically — express-jsdoc-swagger reads JSDoc comments from route handlers and generates interactive docs at /api-docs. Students learn that code is written once but read many times — documentation is not optional, it's part of the deliverable.

Arduino Uno: 8-bit ATmega328P, 16MHz, 2KB RAM, no wireless. ESP32: dual-core Xtensa LX6 32-bit, 240MHz, 520KB RAM, Wi-Fi 802.11 b/g/n, Bluetooth 4.2 + BLE, 12-bit ADC (4096 levels vs Arduino's 1024), hardware AES encryption, touch sensor inputs, hall sensor, ULP co-processor for deep sleep. Same Arduino IDE — identical programming syntax. Espressif (Shanghai, China) ships 100+ million ESP32 chips per year. Every TP-Link smart plug, Wipro smart bulb, and Xiaomi smart sensor in your home almost certainly runs an ESP32 or its sibling ESP8266. A ₹250 chip that connects a sensor to the entire internet — the democratisation of IoT.

MQTT (Message Queuing Telemetry Transport) was invented by IBM's Andy Stanford-Clark in 1999 for monitoring oil pipelines in the desert via satellite. Satellite bandwidth cost ₹15/kilobyte. Design goals: minimal bandwidth, minimal battery, reliable delivery on unreliable networks. Pub/Sub architecture: client publishes to a topic string (home/bedroom/temperature). Any subscriber to that topic receives the message instantly. The broker (Mosquitto, HiveMQ, AWS IoT Core) handles routing — publishers and subscribers never communicate directly. Three QoS levels: 0 = fire and forget (fastest, may lose), 1 = at least once (may duplicate), 2 = exactly once (slowest, guaranteed). Facebook Messenger uses MQTT for message delivery — your chat messages are MQTT packets.

Mosquitto is the most widely deployed MQTT broker. apt install mosquitto on the school Raspberry Pi. Edit /etc/mosquitto/mosquitto.conf: listener 1883, allow_anonymous true (for learning — never in production without authentication). mosquitto_pub -h localhost -t "test/hello" -m "World" publishes from terminal. mosquitto_sub -h localhost -t "test/#" subscribes to all subtopics of test/. The # wildcard matches any multi-level subtopic. + matches one level: home/+/temperature matches home/bedroom/temperature and home/kitchen/temperature but not home/bedroom/sensor1/temperature. Students run their own broker — experiencing first-hand that "the cloud" is just someone's computer running a service they could run on a ₹2,000 RPi Zero.

Node-RED (IBM, 2013) was designed for the Internet of Things by Nick O'Leary — connecting devices without deep expertise. Flow diagram: MQTT-in node receives message → JSON-parse node extracts values → gauge node renders on dashboard → function node applies logic (if temp > 38: trigger alert) → Telegram notification node sends alert. The dashboard is accessible from any browser on the LAN at http://[RPi-IP]:1880/ui. NASA's Jet Propulsion Laboratory used Node-RED for Mars mission telemetry visualisation. Its simplicity is genuine — senior engineers use it for rapid prototyping before writing production code. The PREKSHA class dashboard: any teacher can see all sensor readings on a projector without touching code.

Instead of publishing raw numbers to separate topics (one topic per sensor), professional IoT systems publish structured JSON to a single topic: {"device":"esp32_lab1","ts":1718000000,"temp":28.5,"humidity":72,"pressure":1013.2,"aqi":45}. Benefits: single MQTT subscription per device, timestamp for data logging, device ID for multi-device setups, atomic data snapshot (all readings at the same moment). JSON is the universal data exchange format — 70% of web APIs use it. The ESP32 serialises sensor values using ArduinoJson library: doc["temp"]=dht.readTemperature(); serializeJson(doc, payload); client.publish("sensors/env", payload).

ESP32 active mode: ~250mA at 3.3V = 825mW. On a 1000mAh LiPo battery: ~4 hours. ESP32 deep sleep: ~10μA = 0.033mW. Deep sleep with 30-second wake interval: average power = (250mA × 0.5s active) / 30s + 10μA asleep ≈ 4.2mA average. Same 1000mAh battery: ~238 hours (10 days). esp_deep_sleep_start() sends the ESP32 to deep sleep. esp_sleep_enable_timer_wakeup(30 * 1000000) sets 30-second wakeup timer. This technique extends field sensor battery life from hours to months. Smart agricultural sensors (in mango orchards, vineyards) transmit temperature data every 30 minutes and run on a single charge for 6 months — deep sleep is why.

GPS (Global Positioning System) uses 24 satellites in medium Earth orbit at 20,200km altitude. Each satellite broadcasts its precise location and the exact time on an atomic clock. Your receiver measures the travel time of the signal (at speed of light) from each satellite — 1 nanosecond error = 30cm position error. With 4+ satellites visible, trilateration gives 3D position. NEO-6M outputs NMEA 0183 sentences over UART at 9600 baud: $GPGGA,123519,1848.9600,N,07256.8800,E,1,08,0.9,392.0,M,... — time in HHMMSS, latitude in degrees+minutes, longitude, fix quality, satellite count, HDOP (accuracy estimate), altitude. TinyGPS++ library parses these 40-character strings into decimal degrees (18.816°N, 72.948°E) usable for Google Maps.

Firebase RTDB stores JSON and pushes changes to all subscribers in real time. From ESP32: HTTP PATCH request to https://[project].firebaseio.com/gps.json updates the GPS object. From the browser: database.ref('gps').on('value', snapshot => moveMapMarker(snapshot.val())) subscribes to changes — the callback fires instantly whenever ESP32 updates the value. No polling required. The Google Maps marker moves within 1–2 seconds of the GPS reading. Firebase's free tier: 1GB storage, 10GB/month transfer, 100 simultaneous connections — more than enough for a classroom IoT project. In 2016, Firebase processed 1 billion database operations per day.

Scikit-learn models work on tabular data — rows and columns of numbers. Images don't naturally fit tables. To classify cats vs dogs with Random Forest, a researcher must manually engineer features: average colour histogram (256 bins), edge density from Sobel filter, Fourier descriptors for shape, histogram of oriented gradients. Each feature requires domain expertise and weeks of experimentation. Neural networks eliminate this bottleneck: feed raw pixels directly, the network discovers which pixel patterns matter automatically during training. The features a deep neural network learns are often impossible for humans to articulate — local receptive fields, Gabor-like edge detectors, colour blobs — but they're mathematically optimal for the task at hand.

A single neuron computes: output = activation(w₁x₁ + w₂x₂ + ... + wₙxₙ + bias). Weights determine how much each input influences the output. Bias shifts the activation threshold. Activation function introduces non-linearity. ReLU(x) = max(0,x): zero for negatives, identity for positives. Without activation, stacking N layers is mathematically identical to one layer (just a different linear transformation). ReLU is why deep networks can represent non-linear functions. Sigmoid maps to (0,1) — historically used for output layers in binary classification. Softmax maps to probability distribution summing to 1 — used for multi-class classification output. The Class 9 CNN for plant disease uses Softmax with 38 outputs.

Forward pass: input pixels → through all layers → produce prediction. Loss: cross-entropy measures how wrong the prediction was (-log(correct_class_probability)). If correct class probability was 0.9: loss = -log(0.9) = 0.105. If 0.01: loss = -log(0.01) = 4.6 — much higher penalty for wrong predictions. Backward pass: chain rule of calculus computes the gradient of the loss with respect to every weight in the network. ∂Loss/∂w tells us: if this weight increased by 0.001, how much would the loss change? Gradient descent: w = w - learning_rate × ∂Loss/∂w — nudge every weight slightly to reduce loss. Repeat across millions of training examples. After millions of iterations, the loss converges to a minimum and the model predicts accurately.

MobileNetV2 was trained by Google on 14 million ImageNet images across 1000 categories, running 3 weeks on 32 Google Cloud TPUs. It already encodes knowledge about edges (early layers), textures (middle layers), and object parts (late layers). You add 2 layers for your specific task (38 plant disease classes): GlobalAveragePooling2D() collapses spatial dimensions, Dense(38, activation='softmax') classifies. Freeze the base model (keep Google's weights), train only your new head (2 layers vs 155 in the full network). Result: 85%+ validation accuracy in 10 minutes on a free Colab GPU. Training from scratch on the same dataset: 40% accuracy in the same time. This is why every AI startup does transfer learning — starting from pre-trained weights is not cheating, it's engineering wisdom.

tf.keras.preprocessing.image.ImageDataGenerator(rotation_range=30, width_shift_range=0.2, height_shift_range=0.2, horizontal_flip=True, zoom_range=0.2, brightness_range=[0.8,1.2]). Each training image is randomly transformed before each epoch — the model never sees the same transformation twice. A leaf photo rotated 25° is still a diseased leaf. Flipped horizontally: still diseased. Zoomed 15%: still diseased. This makes the model invariant to these transformations, reducing overfitting by 10–20%. Without augmentation on 1000 images, the model memorises the exact 1000 photos. With augmentation, it sees effectively infinite variations.

EarlyStopping(monitor='val_loss', patience=5): stop training if validation loss doesn't improve for 5 consecutive epochs. Saves time, prevents overfitting past the optimal point. ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=3): halve the learning rate when stuck. Coarse learning rate makes large jumps initially (fast progress). Fine learning rate makes tiny adjustments near the minimum (better accuracy). ModelCheckpoint(filepath='best_model.h5', save_best_only=True): saves the best-performing weights, not the final weights (which may be worse if training overshot). These three callbacks combined make training roughly 2× more efficient with no code changes to the model architecture.

The full Keras MobileNetV2 model: 14MB, requires TensorFlow runtime (~500MB). TFLite converter applies quantisation: convert 32-bit float weights to 8-bit integers. 14MB → 3.5MB (4× smaller). 32-bit float multiply on CPU: slow. 8-bit integer multiply: fast hardware acceleration on ARM chips. Accuracy impact: typically <0.5% drop for int8 quantisation on image classifiers. The TFLite model runs on a Raspberry Pi Zero (512MB RAM), an Android phone, or even an ESP32-S3 with PSRAM. This is Edge AI — intelligence running directly on the sensor hardware, with no internet connection needed. A farmer in a field with no signal can diagnose crop disease on-device.

st.title("Crop Disease Detector"). uploaded = st.file_uploader("Upload a leaf photo", type=['jpg','png']). if uploaded: img = Image.open(uploaded).resize((224,224)). arr = tf.keras.preprocessing.image.img_to_array(img) / 255.0. pred = model.predict(np.expand_dims(arr,0))[0]. st.image(img). st.success(f"Disease: {class_names[np.argmax(pred)]} ({max(pred)*100:.1f}% confidence)"). st.info(f"Treatment: {treatment_dict[class_names[np.argmax(pred)]]}"). That's the complete app — 12 lines. Deployed to Streamlit Community Cloud via GitHub in 2 minutes, public URL, free hosting. The same architecture (image in → model predict → result out) is used by every consumer AI product from Google Lens to ophthalmology diagnosis apps.

React was created at Facebook in 2013 to solve one specific problem: live notification badges were consistently out of sync with the actual unread count. Traditional DOM manipulation maintained multiple sources of truth — UI updated in some places but not others. Jordan Walke's insight: make the UI a mathematical function. UI = f(state). When state changes, React re-derives the entire UI. The virtual DOM diffing algorithm (React Fiber, rewritten 2017) makes this efficient — only changed DOM nodes are actually updated. The mental model shift: stop thinking "I'll update this span's text" and start thinking "I'll update the state, and the UI will reflect it automatically." Instagram, WhatsApp Web, Airbnb, Discord, and Netflix all use React.

useState creates a state variable and a setter: const [count, setCount] = useState(0). Calling setCount(5) schedules a re-render with the new value. React batches multiple setCount calls in the same event handler into one render pass. useEffect runs side effects after render: data fetching, event subscriptions, timers. Dependency array controls frequency: [] runs once on mount (fetch initial data), [userId] runs when userId changes (fetch new user's data), no array runs after every render (almost always a bug). The most common React error: useEffect data fetch without an AbortController → memory leak when component unmounts. Every production React app has hit this.

Prop drilling: state in a top-level component needs to reach a deeply nested component — passed through 5 intermediate components that don't use it, just pass it down. Any change to the state shape breaks all 5 intermediate components. Redux Toolkit solves this: a global store. createSlice() generates actions and reducers in one function: counterSlice = createSlice({name:'counter', initialState:0, reducers:{increment: state => state+1}}). useSelector(state => state.counter) reads from store in any component. useDispatch() sends actions. Redux DevTools lets you inspect every state change in sequence and "time-travel" backwards to debug. Real rule: useState for local component state, useContext for nearby shared state, Redux for state shared by many distant components (user auth, shopping cart, theme).

Traditional navigation: every URL change = full HTTP request = server returns new HTML = full page render (slow, flash). React Router: URL changes are handled in JavaScript — the browser updates the URL bar without making an HTTP request. The component tree is updated based on the new URL pattern. <Route path="/products/:id" element={<ProductDetail />} /> matches /products/42 and passes id="42" via useParams(). Nested routes build layouts: <Route path="/dashboard" element={<DashboardLayout />}> wraps child routes that render inside the layout. useNavigate() programmatically navigates after form submission. React Router is used by every React SPA — there is no alternative that matches its adoption.

HTTP is half-duplex: client sends request, server sends response, connection closes. WebSockets establish a persistent full-duplex TCP connection — both sides can push at any time. Socket.io wraps WebSockets with: automatic reconnection, fallback to HTTP long-polling for environments that block WebSockets, and a room/namespace system. Server: io.to('room-name').emit('event', data) broadcasts to everyone in the room. Client: socket.on('event', handler) listens for events. The PREKSHA Class 10 chatroom implements: room join/leave, message broadcast, typing indicator (keydown event → emit 'typing' → clear after 3s inactivity → emit 'stop-typing'), emoji reactions (click → emit 'react', server broadcasts new count to room). Real users — other Class 10 students — use this chatroom for project coordination from the day it's deployed.

CI/CD (Continuous Integration/Continuous Deployment) means: every time you push code, an automated pipeline verifies it's safe to deploy and deploys it. The .github/workflows/ci.yml file defines the pipeline: on push → checkout code → install Node.js → run npm ci (clean install) → run ESLint (code style) → run TypeScript compiler check → run Jest unit tests → run next build → deploy to Vercel. If any step fails, the pipeline stops and deployment is blocked — broken code never reaches production. Netflix deploys code ~4,000 times per day via CI/CD. Each deployment is tested automatically in under 10 minutes. Students see their first pipeline failure (a missed semicolon detected by ESLint before deployment) and experience why this workflow exists.

Stripe provides a complete test environment: test API keys, test card numbers (4242 4242 4242 4242 = always succeeds), test webhooks. Payment flow: React checkout page → call your Express API to create a PaymentIntent (never create it client-side — the amount could be modified) → API returns client_secret → Stripe.js takes over, renders its hosted card input (PCI DSS compliance — card numbers never touch your server), → user pays → Stripe calls your webhook endpoint with payment_intent.succeeded event → your server updates order status in MongoDB. Students experience the real production payment flow. The test/production distinction (just swap API keys) is what makes payments deployable.

React SPA (Vercel CDN) — sends requests to — Express API (Railway server) — queries — MongoDB Atlas (cloud cluster). Three separate deployments, three separate environments, all connected via HTTPS. CORS config: app.use(cors({origin:'https://yourapp.vercel.app'})) on Express — only your frontend domain can call the API. JWT in httpOnly cookies (not localStorage) — prevents XSS attacks from stealing tokens. Redux state management: cartSlice (add/remove/update items), authSlice (user info, JWT), orderSlice (order history). Git workflow: feature branch → PR → code review → merge triggers CI/CD → Vercel auto-deploys. First merge conflict: the most educational experience of the project.

By Class 10, students have 4 years of PREKSHA projects: websites, APIs, IoT systems, ML models. A well-maintained GitHub profile showing consistent commits, real deployed projects, and clean README files is more compelling to many hiring managers than a résumé. Students build a simple portfolio page (HTML/CSS or React) listing all projects with description, tech stack, live demo link, and GitHub source link. Deploy to GitHub Pages (free). At Google, Meta, and Flipkart, engineering hiring managers spend 30 seconds on a GitHub profile before reading a résumé. A profile with 5 deployed projects wins that 30 seconds. Students maintain this for the rest of their career.

Create React App produces a Single Page App: one HTML file, JavaScript renders everything client-side. Problem 1: Google's crawler receives an empty HTML shell, can't index content — SEO catastrophe. Problem 2: First Contentful Paint is delayed until the entire JavaScript bundle downloads and executes — slow on mobile. Next.js solves both. Three rendering strategies: SSG (Static Site Generation — built once at deploy time, fastest, ideal for marketing pages and blogs), SSR (Server Side Rendering — fresh HTML generated on each request, ideal for personalised dashboards), ISR (Incremental Static Regeneration — SSG but stale-while-revalidate — revalidate every N seconds in background). React Server Components (Next.js 14 App Router): run entirely on the server, can query databases directly, ship zero JavaScript to the browser. Vercel (Next.js creators) powers Twitch, HashiCorp, GitHub's marketing site, and thousands of production apps.

JavaScript is dynamically typed — type errors only surface at runtime, potentially in production with real users. function greet(name) { return "Hello " + name.toUpperCase() } — if you call greet(42), it crashes at runtime: TypeError: name.toUpperCase is not a function. TypeScript catches this at write time: function greet(name: string): string — the compiler immediately underlines greet(42) before you run a single line. TypeScript adoption: 12% of JS projects in 2019, 42% in 2024. Microsoft, Google, Meta, Airbnb, Lyft, and Slack all require TypeScript for new projects. The productivity gain is real: in a 2017 Airbnb study, TypeScript would have prevented 38% of their production bugs. The type annotations also serve as living documentation — no need to read function bodies to understand expected inputs.

Traditional ORMs (Sequelize, SQLAlchemy) generate dynamic queries — TypeScript can't infer the return type of a JOIN query. Prisma generates a fully typed client from your schema: model User { id Int @id @default(autoincrement()), name String, posts Post[] }. prisma.user.findMany({where:{posts:{some:{published:true}}}}) — TypeScript knows the exact shape of every returned object. IntelliSense autocompletes all field names. A schema change (rename a field) causes TypeScript errors at every usage site — no silent regressions. Prisma Migrate creates SQL migration files and applies them: prisma migrate dev --name add-user-role. Migration history is committed to Git — the database schema is version-controlled like code.

Traditional CMS (WordPress): content management and rendering are coupled — changing the CMS changes the frontend. Headless CMS: content lives in Contentful, exposed via REST or GraphQL Content Delivery API. Your Next.js app fetches content at build time (getStaticProps) or request time (getServerSideProps). Benefit: marketing team edits blog posts via Contentful's polished UI without touching code. The frontend can be completely rebuilt/redesigned without touching the content. Same content can feed a website, mobile app, and email newsletter. With ISR (revalidate:60), a Contentful update appears on the website within 60 seconds — no deployment. Sanity, Strapi, and Ghost are alternatives. Contentful's free tier allows 5,000 records and 25 users — more than enough for a portfolio CMS.

motion.div animate={{x:0, opacity:1}} initial={{x:-50, opacity:0}} transition={{type:"spring", stiffness:80, damping:15}}. Spring physics produces natural deceleration — the same feel as iOS rubber-band scroll and Android shared element transitions. Variants enable orchestrated animations: parent variants control when child variants animate (staggerChildren:0.08 creates card-by-card staggered entry). AnimatePresence handles unmount animations — elements animate out before being removed from DOM. useScroll + useTransform creates parallax tied to scroll position. Performance rule: only animate transform (translate, scale, rotate) and opacity — these are GPU-accelerated. Never animate width, height, top, left — these trigger layout recalculation on every frame. A 60fps animation has 16.67ms per frame; layout reflow can take 30ms+.

Google's Core Web Vitals are ranking signals since June 2021. LCP (Largest Contentful Paint): time until the hero image or main text block is visible. Target: <2.5s. A 100ms delay in LCP reduces conversions by 1% (Google/Deloitte research). INP (Interaction to Next Paint, replaced FID in 2024): time from user click/tap to visual response. Target: <200ms. CLS (Cumulative Layout Shift): how much content jumps as the page loads. Target: <0.1. Cause: images without width/height attributes (browser doesn't know size, causes reflow when loaded). Fix: always set width and height on img. Next.js Image component automatically handles this, plus lazy loading, WebP conversion, and responsive sizes. Students audit their portfolio with Chrome Lighthouse and achieve >95 on all four metrics.

The Class 11 portfolio is the project students will use for the rest of their careers. Next.js 14 + TypeScript + Contentful CMS (add projects without redeployment) + Framer Motion page transitions + Resend email API for contact form + Google Analytics. Projects section pulls from Contentful — each project has title, description, tech tags, live URL, GitHub URL, thumbnail. The Contentful model ensures consistent structure across all 42 PREKSHA projects and any future work. Lighthouse score >95. Deployed on Vercel with a custom domain (₹800/year for .com). At Google, Facebook, and Flipkart, engineering hiring managers spend 30 seconds on a GitHub profile before reading a résumé. Five deployed projects with live URLs wins those 30 seconds. Students own this domain for life.

OAuth 2.0: user clicks "Login with Google" → redirected to Google's login page → user approves → Google returns an authorization code → your server exchanges code for access token → creates session → user is logged in. Users never share their Google password with your app — Google handles authentication. NextAuth.js implements OAuth in ~50 lines of config: providers[Google({clientId, clientSecret}), GitHub({clientId, clientSecret}), Credentials({authorize:async(credentials) => authenticate(credentials)})] — three providers in one array. Database adapter stores sessions in your Prisma database. CSRF protection, secure cookie handling, and token rotation all included. Email magic link: NextAuth sends a one-time login URL — passwordless auth used by Notion, Linear, and most modern SaaS tools.

A 3-DOF planar robot arm has three joints: shoulder (θ₁), elbow (θ₂), wrist (θ₃) with link lengths L₁, L₂, L₃. Forward kinematics (easy): given θ₁, θ₂, θ₃ → compute end-effector (x, y) using trigonometry. Inverse kinematics (harder): given target (x, y) → compute θ₁, θ₂, θ₃. For a 2-DOF arm: use law of cosines to find θ₂ (elbow angle), then atan2(y, x) to find θ₁ (shoulder angle). Two solutions exist: elbow-up vs elbow-down — choose based on workspace constraints. Adding the third DOF (wrist) sets the end-effector orientation. The 3D-printed links must have the correct joint geometry to match the kinematic model — mechanical accuracy directly affects the IK calculation's validity. Students design links in Tinkercad with precise joint-to-joint measurements before printing.

PID (Proportional-Integral-Derivative) is the most widely deployed control algorithm — used in aircraft autopilots, temperature regulators, motor drives, and cruise control. P: output = Kp × error. Responds to current error — large error → large correction. Too much Kp → oscillation. I: output += Ki × Σerror. Accumulates past error — eliminates steady-state error that P alone can't remove (e.g., a motor that settles 2° below target). Too much Ki → slow oscillation (integral windup). D: output += Kd × Δerror/Δt. Predicts future error from rate of change — damps overshoots before they occur. Too much Kd → amplifies sensor noise, jerky motion. Tuning: Ziegler-Nichols method — increase Kp until sustained oscillation, then use formulas to derive Ki and Kd. Students tune empirically: adjust, observe, adjust. This empirical process is exactly how professional control engineers tune industrial systems.

Tkinter is Python's built-in GUI framework. A Canvas widget displays a 2D overhead view of the robot's reach envelope. The user clicks a target point on the canvas — the click event's (x,y) in canvas coordinates is converted to robot workspace coordinates — Python IK solver computes θ₁, θ₂, θ₃ — joint angles are sent over serial to Arduino (which drives the MG996R servos with smooth interpolation). The visual canvas updates to show the robot arm's current configuration. Real-time inverse kinematics driving physical hardware, controlled through a GUI — all in Python. The IK solver runs in a separate thread so the GUI remains responsive during calculation.

Joseph Redmon's YOLO (2015) was the first real-time object detector. Previous detectors ran a region proposal network then a classifier — two forward passes per image. YOLO divides the image into an S×S grid. Each cell predicts B bounding boxes (centre x, y, width, height, confidence) and C class probabilities simultaneously in one forward pass. The entire prediction is a single tensor operation. YOLOv8 (Ultralytics, January 2023) achieves mAP@50 of 53.9 on COCO benchmark, inference in 1.8ms on GPU (NVIDIA A100). Five model sizes: nano (1.9MB, 80.4% mAP), small, medium, large, extra-large (68.9MB, 86.0% mAP). Nano runs on a Raspberry Pi. Extra-large runs in Tesla's Autopilot. Students use YOLOv8 nano for real-time webcam inference and medium for fine-tuning on custom data.

A model is only as good as its training data. Data quality matters more than model architecture for custom object detection. Roboflow provides: web-based image annotation (draw bounding boxes, label classes in a browser — no software to install), dataset management (train/val/test split, automatic versioning, dataset analytics showing class distribution), augmentation (flip, rotate, brightness, noise, blur, mosaic — multiplies dataset size 3–15×), export to YOLO format (txt files with normalised bounding box coordinates alongside images). mAP@50 (Mean Average Precision at 50% IoU threshold): for each class, precision and recall at the threshold where a prediction counts as correct if the predicted bounding box overlaps the ground truth by >50%. mAP averages across all classes. Students annotate 200 images per class (5 lab equipment classes = 1000 total images) — directly experiencing why data labelling is 60% of ML project time in industry.

from ultralytics import YOLO. model = YOLO('yolov8m.pt') — loads ImageNet pre-trained weights. model.train(data='lab_equipment.yaml', epochs=50, imgsz=640, batch=16, device='cuda') — fine-tunes on your annotated dataset. The YAML file defines: train/val paths, nc (number of classes), names (class names). Ultralytics handles the training loop, learning rate scheduling, augmentation, and checkpointing. After 50 epochs: evaluate with model.val() — prints per-class mAP@50, precision, recall. model.predict(source='webcam') — real-time inference on webcam feed. Students compare YOLOv8n (fast, less accurate) vs YOLOv8m (slower, more accurate) on their custom dataset — experiencing the accuracy/speed tradeoff firsthand.

ROS 2 (Robot Operating System 2, open-source since 2014) is the standard middleware for robotics research and production systems. Not a traditional OS — it's a communication framework. Core concepts: Node (an independent process: sensor_reader, path_planner, motor_controller), Topic (a named message channel: /scan for LiDAR data, /cmd_vel for velocity commands), Publisher (node that writes to a topic), Subscriber (node that reads from a topic). Launch files start multiple nodes simultaneously: ros2 launch my_robot bringup.launch.py. Quality of Service (QoS) settings control reliability vs speed tradeoffs. Used in: Boston Dynamics Spot, NASA JPL's open-source tools, Open-RMF (robotics fleet management standard used in Singapore's Changi Airport). Intro to ROS 2 in Class 11 positions students for university robotics courses and ISRO/DRDO internships.

The complete Class 11 T2 capstone integrates all year's learning: YOLOv8 on webcam detects lab equipment (Arduino, breadboard, multimeter, RPi, soldering iron) in real-time. A "baseline inventory" is established at session start (which items are on the bench). If an item disappears from detections for >5 consecutive seconds, an alert fires: Telegram message + timestamp + screenshot. If the item reappears, a "returned" notification is sent. Dashboard (Streamlit): shows live webcam feed with bounding boxes, detection log, inventory status per item (Present/Missing/Alert). This is the exact workflow used by smart retail shelving systems: Trigo's computer vision system for retail stores detects shelf stockouts and alerts staff within 3 minutes — the same detection logic, professional deployment.

LLMs hallucinate because next-token prediction has no mechanism to check factual accuracy. RAG solves this architecturally: instead of asking the model to recall information from training (unreliable), give it the relevant information at query time. Pipeline: query arrives → embed the query as a vector → similarity search in vector database → retrieve top-K most relevant document chunks → prepend chunks to the LLM prompt ("Here is the relevant context: [chunks]. Now answer: [query]") → LLM reasons over the provided context → returns answer with citations. The LLM becomes a reasoning engine over your documents — it's grounded. Hallucinations drop dramatically because the model no longer needs to recall facts from training; it just needs to read and reason over the provided text.

Word embeddings map semantic meaning to numerical vectors. OpenAI ada-002: converts any text to a 1,536-dimensional float32 vector. Texts with similar meanings produce vectors with high cosine similarity: "The dog ran fast" and "The canine sprinted quickly" → similarity ~0.92. "The dog ran fast" and "Water boils at 100°C" → similarity ~0.15. The famous word arithmetic: vector("king") - vector("man") + vector("woman") ≈ vector("queen"). Cosine similarity = (A·B) / (|A||B|) — the cosine of the angle between two vectors. Value 1.0 = identical meaning. Value 0.0 = orthogonal (unrelated). Value -1.0 = opposite meaning (rare in practice). Documents chunked into 512-token pieces, each embedded separately, stored in Pinecone. At query time: embed the query, search Pinecone for the K vectors with highest cosine similarity, retrieve those chunks.

LangChain (released October 2022, 70K+ GitHub stars by 2023) provides abstractions for common LLM application patterns. RetrievalQA: combines vector retrieval and LLM answering in 5 lines: qa = RetrievalQA.from_chain_type(llm=ChatOpenAI(), retriever=vectorstore.as_retriever(search_kwargs={"k":5})). qa.run("What topics are in Class 9 IoT?") retrieves relevant PREKSHA curriculum chunks and generates an answer citing them. ConversationBufferMemory stores the last N turns of conversation, passed as context. LangChain Expression Language (LCEL): compose chains declaratively using | pipe operator. chain = prompt | llm | output_parser. Each component is composable and replaceable — swap OpenAI for Anthropic Claude in one line.

BERT (Google, 2018): Bidirectional Encoder Representations from Transformers. Pre-trained on Wikipedia and BooksCorpus: predict masked words, predict if sentence B follows sentence A. 110M parameters. DistilBERT (Hugging Face, 2019): knowledge distillation from BERT → 66M parameters, 40% smaller, 60% faster, 97% of BERT's accuracy. Fine-tuning for 4-class toxicity classification: add a linear classification head on top of DistilBERT's [CLS] token output. Freeze pre-trained weights initially, train only the classification head (faster, less overfitting). Then unfreeze the top 2 transformer layers for further refinement. Loss: BinaryCrossEntropy (multi-label: a text can be simultaneously hateful AND a threat). Class weighting: toxic:non-toxic ratio is 1:99 in real data — without weighting, model predicts "non-toxic" for everything and achieves 99% accuracy while detecting 0 actual toxicity.

Flask was simple for prototyping. FastAPI is production-grade. Built on Pydantic (automatic request/response validation) + Starlette (ASGI framework for async). class TextInput(BaseModel): text: str. @app.post("/classify") async def classify(input: TextInput): — incorrect request type returns HTTP 422 automatically, no manual validation code. Async endpoints (async def) handle concurrent requests: multiple inference calls can execute in parallel. Auto-generated Swagger UI at /docs: interactive API documentation that tests itself. Server-Sent Events for streaming: @app.get("/stream") async def stream(): yield "data: token " — enables streaming LLM responses instead of waiting for the full completion. Deployed on Railway with uvicorn ASGI server, Docker container.

Without MLflow: you run 20 training experiments with different hyperparameters, save models with generic names (model_v3_final_FINAL.h5), lose track of which configuration produced which accuracy. With MLflow: with mlflow.start_run(): mlflow.log_param("learning_rate", 0.001). mlflow.log_metric("f1_toxic", 0.83). mlflow.log_artifact("confusion_matrix.png"). mlflow.sklearn.log_model(model, "distilbert_toxicity"). Every experiment recorded in a database with searchable UI. mlflow.register_model() versions your models: v1 (baseline), v2 (class-weighted), v3 (fine-tuned top layers). Promote v3 to "Production" stage. If v3 degrades in production, roll back to v2 in one click. This reproducibility — knowing exactly how any model was trained — is required in healthcare AI (FDA audit trails) and fintech (regulatory compliance) and increasingly standard everywhere.

After training the toxicity classifier, students measure demographic parity: does the model have equal false-positive rates across different groups? Test: feed phrases like "I am gay", "I am Christian", "I am Muslim", "I am a man", "I am a woman" → record predicted toxicity score. A fair model should give near-zero toxicity to all. Common finding: models trained on internet comments data over-flag demographic identity statements from underrepresented groups (because those phrases appeared disproportionately in hostile contexts in the training data). Tools: AI Fairness 360 (IBM open-source), Fairlearn (Microsoft). Students write a formal Model Card: intended use, training data description, evaluation metrics, known failure modes, demographic performance disparities, deployment recommendations. Required by responsible AI frameworks worldwide.

The human moderator React dashboard: shows a queue of model predictions with confidence scores. Moderator clicks Approve (model was right), Override-Toxic (model missed toxic content), Override-Clean (model false-flagged). All decisions logged to PostgreSQL: text, model_prediction, human_decision, timestamp. Weekly retraining pipeline: SELECT * from decisions WHERE model_prediction != human_decision → add disagreement examples to training set with human labels → retrain DistilBERT → evaluate on held-out test set → if F1 improved → promote new version in MLflow registry → update FastAPI to serve new model version. This continuous learning loop prevents model staleness. Without it, models trained on 2020 internet language fail at 2025 internet slang and new toxic patterns.

A monolith: one codebase, one database, one deployment. Works perfectly for 3 engineers and 1,000 users. Amazon in 2001: 10,000 engineers changing the same codebase. Deployments took weeks. One team's bug blocked all other deployments. Jeff Bezos issued his famous "API Mandate" memo in 2002: "All teams will henceforth expose their data and functionality through service interfaces. Teams will communicate with each other through these interfaces. There will be no other form of interprocess communication allowed." By 2006, Amazon had ~100 microservices. Today: ~3,000. Netflix's 2009 decomposition: their DVD shipping monolith moved to cloud microservices — each service owned by a 2-pizza team (small enough to be fed with 2 pizzas). Class 12 implements 3 microservices: Auth (Node + PostgreSQL), Products (Node + MongoDB), Orders (Node + Redis). Each in its own Docker container, communicating via HTTP. An API Gateway routes all external traffic.

Docker containers package an application and its entire runtime environment (specific Node.js version, OS libraries, environment variables, file system structure) into a portable unit. The Dockerfile is a recipe: FROM node:20-alpine (base image) → WORKDIR /app → COPY package.json . → RUN npm ci (clean install) → COPY . . → EXPOSE 3000 → CMD ["node", "server.js"]. docker build -t auth-service:v1.0 . creates the image. docker run -p 3001:3000 auth-service:v1.0 starts a container. Docker Compose: YAML file defines all services + databases + networks + volumes. docker-compose up starts the entire microservices platform locally in one command. The same docker-compose.yml that runs locally works identically in production — guaranteed. This eliminates the entire class of "environment inconsistency" bugs that previously consumed 30% of engineering time.

External clients (React frontend) shouldn't know about internal service topology — which service runs on which port. An API Gateway provides a single entry point: all requests to /api/auth/* routed to auth-service:3001, /api/products/* to products-service:3002, /api/orders/* to orders-service:3003. The gateway handles: JWT verification (check token before forwarding to any downstream service — each service trusts the gateway), rate limiting (100 requests/15 minutes per IP, applied once at the gateway), request logging (distributed tracing), CORS headers (applied centrally). Implementing an API Gateway from scratch with Express teaches all these concepts. Production alternatives: Kong, AWS API Gateway, Nginx (with Lua plugins). Students build with Express; understanding the pattern transfers to any implementation.

Peter Deutsch's 8 Fallacies of Distributed Computing (1994): "The network is reliable. Latency is zero. Bandwidth is infinite. The network is secure. Topology doesn't change. There is one administrator. Transport cost is zero. The network is homogeneous." Every one of these is false. When the Orders service calls the Products service to check stock: that HTTP call can fail (network unreliable), be slow (latency non-zero), or hang indefinitely (no timeout). Circuit breaker pattern: if Products service fails 5 times in 30 seconds, stop calling it for 60 seconds (return cached data or error) — prevents cascading failures. Timeout: every external HTTP call has a 3-second timeout. Retry: retry on network errors, not on 4xx errors. Students implement these three patterns explicitly — they're the difference between "it works in demo" and "it works in production."

Playwright (Microsoft, 2020) automates a real browser — Chrome, Firefox, or Safari — in headless mode (no visible window). test('user can complete checkout', async ({page}) => { await page.goto('/login'); await page.fill('[name="email"]', '[email protected]'); await page.fill('[name="password"]', 'password'); await page.click('[type="submit"]'); await expect(page).toHaveURL('/dashboard'); await page.click('text=Add to Cart'); await page.click('text=Checkout'); await page.fill('[data-stripe-element]', '4242424242424242'); await expect(page.locator('.order-confirmed')).toBeVisible(); }). The test clicks, types, and verifies exactly as a real user would. Runs in CI: GitHub Action → Playwright headless → screenshots on failure showing exactly what went wrong. Trace viewer replays failed tests step-by-step. Students write 10 E2E tests covering: auth flow, workspace creation, product CRUD, payment intent, admin actions.

The .github/workflows/ci.yml: on [push to main, pull_request] → jobs: lint (ESLint), typecheck (tsc --noEmit), test (Jest unit tests), e2e (Playwright on Docker Compose stack), build (next build or docker build), deploy (Vercel deploy action). Each job runs in a separate Ubuntu container. Matrix strategy: test against Node.js 18 and 20 simultaneously. Caching: actions/cache@v3 for node_modules — reduces pipeline from 8 minutes to 2.5 minutes. Branch protection rules: require all checks to pass before merge. Environment secrets: STRIPE_SECRET_KEY, DATABASE_URL stored encrypted in GitHub Secrets, injected as environment variables during deployment. Pull request preview deployments: every PR gets its own Vercel preview URL — review the feature in a real environment before merging.

Stripe Billing separates pricing from product: Products (Free Plan, Pro Plan, Enterprise Plan) have one or more Prices (Free: ₹0/month, Pro: ₹999/month, Enterprise: ₹9999/month). Customer Portal: a Stripe-hosted page where customers manage their subscription — upgrade, downgrade, cancel, update payment method. Your server creates a portal session URL, redirects the user. Zero UI code from you. Webhooks handle subscription state changes: customer.subscription.created → set user plan to pro. invoice.payment_succeeded → extend subscription. customer.subscription.deleted → downgrade to free. Idempotency: process each webhook event exactly once using the event ID as an idempotency key stored in the database. Stripe's Radar fraud detection protects test and production transactions. Students see real Stripe test payments appearing in the Stripe dashboard.

A product pitch structure: (1) Problem — what specific pain, for whom, how large is the addressable market? "15 million Indian school students spend 2 hours/week searching for curriculum content across scattered resources." (2) Solution — live demo, 4 minutes, show the product actually working with realistic data. (3) Technical architecture — one diagram, explain each layer in 90 seconds at the right level for the audience. (4) Metrics — Lighthouse score, API response time (p50, p95), test coverage %, deployment frequency. Numbers, not adjectives. (5) Business model — how does it make money? Cost per user on current infrastructure? (6) Team — who built what, what did each person learn? (7) Ask — if you had 3 more months, what would you improve? Honest self-assessment of limitations is more impressive than overselling. Panel: 1 PREKSHA faculty + 2 invited engineers (startup founders or senior engineers from Pune/Mumbai tech ecosystem). 20-minute pitch + 15-minute Q&A. Graded on clarity, technical depth, and honest assessment of limitations.

Find an issue labelled "good first issue" or "help wanted" on a real open-source project. Read the contributing guidelines (CONTRIBUTING.md). Fork the repository. Create a feature branch. Read the existing code for context (don't just fix the bug — understand the system). Make the fix. Write a test if the project has tests. Run the full test suite locally. Commit with a descriptive message (Fix: incorrect error message for empty array input). Push and open a PR with a clear description of what you changed and why. Respond to code review feedback — maintainers may request changes 2–3 times before merging. When merged: your GitHub profile shows a contribution to a real project that thousands of people use. Projects welcoming students: freeCodeCamp, Exercism, FOSSASIA, AsyncAPI — all have Indian contributors and welcoming maintainers.

Dijkstra's algorithm (1956) finds the shortest path by expanding the lowest-cost node first — explores in all directions equally. Problem: on a 5×5 grid, it examines all 25 nodes. On a 1,000×1,000 grid, it examines 1 million nodes. A* (Hart, Nilsson, Raphael, Stanford 1968) adds a heuristic: f(n) = g(n) + h(n). g(n) = actual cost from start to n (known). h(n) = estimated cost from n to goal (Euclidean distance: √(Δx²+Δy²)). The heuristic guides expansion toward the goal. On the 5×5 grid with obstacles, A* examines 10–15 nodes instead of 25. With an admissible heuristic (never overestimates), A* always finds the optimal path. Students implement A* in Python: open set (priority queue sorted by f), closed set (visited nodes), reconstruct path by backtracking parent pointers. Test on 5×5 grid in simulation, then deploy on physical robot.

Rotary encoders measure wheel rotation: a wheel with 20 encoder ticks/revolution and 6.5cm diameter has circumference = π × 6.5 = 20.4cm. Each tick = 20.4cm/20 = 1.02cm of travel. Count ticks over time → compute distance. Differential drive kinematics: track ticks from left (L_ticks) and right (R_ticks) wheels separately. Δleft = L_ticks × cm_per_tick. Δright = R_ticks × cm_per_tick. Δheading = (Δright - Δleft) / wheel_base. Position update: x += Δdistance × cos(heading). y += Δdistance × sin(heading). Error accumulation: each tick measurement has ±0.5 tick error → over 100 ticks, error is ±5 ticks (~5cm). Over 10m, the robot may be 15–20cm off. This is why real autonomous vehicles use SLAM (Simultaneous Localisation and Mapping) to correct odometry drift using detected landmarks. Students experience this drift firsthand and document the accuracy degradation over distance.

Raspberry Pi: runs Linux, Python, A* pathfinding, computer vision, MQTT communication, ROS 2. Handles high-level decisions at ~10–30Hz. Arduino: bare-metal, C++, PID motor control at 100Hz, encoder reading at 1kHz, ultrasonic emergency stop in microseconds. The split exists because RPi Linux OS has non-deterministic scheduling — a kernel interrupt can delay your code by 50ms. For a PID motor controller running at 100Hz, a 50ms skip causes visible jerks. Arduino has no OS: your loop runs at exactly the rate you specify, every time. Serial communication protocol: RPi sends "FORWARD:500mm:200mm/s " → Arduino parses, executes PID to target speed, sends back "DONE:pos_x:pos_y ". Simple, reliable, text-based. No I2C (too slow for bidirectional), no SPI (full-duplex but complex). UART at 115200 baud = 11,520 bytes/second — plenty for command-response at 100Hz.

Three robots, multiple tasks, one coordinator. Greedy nearest-robot algorithm: when a new package arrives at the pickup station, for each idle robot compute Euclidean distance from robot's current grid position to pickup position. Assign the task to the nearest idle robot. Mark robot as "busy." When robot completes task: publish "idle" to MQTT, coordinator assigns next pending task. Time complexity: O(R×T) per assignment (R robots, T tasks) — fast enough for real-time decisions. Suboptimal: greedy doesn't always minimise total time. Optimal multi-robot task allocation (Hungarian algorithm / assignment problem) is O(n³) — tractable for 3 robots and 10 tasks. Students implement both and compare total delivery time across 20 test runs. The greedy algorithm typically achieves 85–95% of optimal performance at 100× less computational cost — the engineering tradeoff students must quantify and defend in their technical report.

Single robot: ultrasonic detects obstacle ahead → stop → re-route via A*. Multi-robot: even if each robot avoids static obstacles, two robots navigating toward the same grid cell simultaneously collide with each other. Solution: the central coordinator maintains a "reserved cells" map. Before executing a path segment, each robot requests reservation of its next cell. If already reserved (by another robot), the robot waits. First-come-first-serve with random tiebreak prevents deadlock. Deadlock can still occur: Robot A holds cell (2,3) and needs (3,3). Robot B holds (3,3) and needs (2,3). Neither can move. Deadlock detection: if any robot hasn't moved for 5 seconds → one robot backs up one cell and replans. This is simpler than full deadlock prevention but sufficient for a 5×5 grid with 3 robots. Students test their deadlock resolution by deliberately creating a T-junction situation.

The Next.js fleet dashboard (same codebase pattern as the Track 1 SaaS project) connects to the MQTT broker via a WebSocket bridge (MQTT over WebSockets, port 9001). The React frontend subscribes to /fleet/+/position and /fleet/+/status topics. A 5×5 SVG grid renders the warehouse. Three robot icons move to their current grid positions as MQTT messages arrive. Task queue sidebar: pending → in-progress → completed with timestamps. KPI cards: deliveries per hour, average task completion time, idle percentage per robot. Alert: battery <20% → robot icon turns red → Telegram notification to the lab instructor. The dashboard is deployed on the same Vercel account as the student's portfolio — demonstrating code and deployment reuse across projects.

Three physical Raspberry Pi robots on a 1m×1m grid board (marked with black tape grid lines). Instructor places 3 coloured packages (red, green, blue blocks) at the pickup station. Students start the fleet — coordinator assigns packages to nearest idle robots. Each robot: navigates to pickup (A* pathfinding + PID motor control), YOLOv8 identifies package colour (same model trained in Class 11), navigates to the correct colour-coded delivery shelf, signals delivery complete. Fleet dashboard on the classroom projector: shows all 3 robots moving in real time, task queue updating, delivery count incrementing. Time trial: how long to deliver 6 packages? Students must achieve <5 minutes for full marks. Panel of 2 PREKSHA faculty + 2 invited engineers asks technical questions during and after: "Why did Robot 2 wait at that grid cell?" "What happens if the ultrasonic false-triggers?" "How does your deadlock resolution work?" The ability to answer under pressure is as important as the demo itself.

Every engineering project requires documentation. Technical report structure: system overview (architecture diagram with all components), pathfinding algorithm analysis (A* implementation, time complexity, comparison with greedy baseline), control systems (PID tuning methodology, Kp/Ki/Kd values justified, response curve graphs), vision system (YOLOv8 confusion matrix, mAP@50 per class, failure cases documented), swarm coordination (task allocation algorithm, deadlock resolution, measured performance vs optimal), known limitations and future improvements. Video documentation: 5-minute screencast of full demo with voiceover explaining each component. Both submitted to a shared PREKSHA project archive — Class 6 students in 2030 will be able to watch Class 12's 2026 demo and be inspired by what's achievable.

Naive RAG fails because of chunking: split a 10-page PDF into fixed 512-token blocks → some chunks cut mid-sentence, losing context. The chunk about "Week 5: Servo motors" is split so "servo" is at the end of chunk 12 and "motor control" starts chunk 13. Vector search returns chunk 12 but the answer is in chunk 13. Solutions: recursive character text splitter (respects paragraphs, then sentences), semantic chunking (split where the topic changes — uses embedding similarity between consecutive sentences to detect topic boundaries). Reranking: initial vector search retrieves top-20 candidates. Cross-encoder reranker (Cohere Rerank API or sentence-transformers cross-encoder) re-scores all 20 by relevance to the specific query. The top-5 after reranking are more accurate than the original top-5. Hybrid search: run BM25 keyword search AND dense vector search simultaneously, merge results via Reciprocal Rank Fusion. Finds documents matching both the meaning AND the specific keywords — best of both retrieval paradigms.

RAGAS (Retrieval Augmented Generation Assessment, Shahul Es et al., 2023) provides automated metrics that correlate with human quality judgements: Faithfulness: for each sentence in the answer, use an LLM to check if it can be inferred from the retrieved context chunks. Score = faithful sentences / total sentences. Target: >0.85. Answer Relevancy: use an LLM to generate N candidate questions from the answer, measure cosine similarity between these generated questions and the original question. High relevancy = the answer addresses the actual question. Target: >0.82. Context Recall: use the ground truth answer to check if the retrieved context contains the information needed to answer correctly. Target: >0.75. These metrics run automatically on a test set of 50 question-answer pairs, giving a quantitative quality score in minutes. Students run RAGAS after every RAG improvement (better chunking, reranking added) to measure the effect — turning AI development from art to engineering.

Without streaming: user asks question → API waits 10 seconds for the full LLM completion → returns the entire answer at once → user stares at a spinner for 10 seconds. With streaming: API sends tokens as they're generated → user sees the answer forming word-by-word → much better perceived responsiveness (same total time, very different experience). Server-Sent Events (SSE): HTTP response with Content-Type: text/event-stream. Server writes "data: token " incrementally. Browser's EventSource API reads tokens as they arrive: source.onmessage = event => append(event.data). FastAPI SSE: async def stream_chat(): async for chunk in openai.stream(): yield f"data: {chunk.choices[0].delta.content} ". Next.js frontend: useEffect to manage EventSource lifecycle, useState to accumulate tokens. The streaming experience is what separates a professional-feeling AI app from a clunky one. Every successful LLM product (ChatGPT, Claude.ai, Gemini) uses streaming.

An AI agent is an LLM that can use tools. OpenAI function calling: define tools as JSON schemas (name, description, parameters). The LLM decides which tool to call based on the user's request. Your code executes the tool and returns the result. The LLM uses the result to continue reasoning. Tool examples: search_curriculum(query) — searches PREKSHA Pinecone database. get_student_progress(student_id) — queries PostgreSQL. send_reminder(student_id, message) — calls the Telegram Bot API. An agent loop: user asks "Which Class 9 students haven't submitted their Node.js project?" → LLM calls get_student_progress for Class 9 → receives list of submissions → identifies missing ones → LLM calls send_reminder for each → summarises actions taken. One query, multiple tool calls, meaningful real-world effect. CrewAI: orchestrate multiple agents with different roles (researcher, writer, critic) working in sequence. AutoGen: agents that write and iteratively fix code until tests pass.

GPT-4V (Vision) accepts images alongside text in the prompt. Applications: OCR replacement (photo of a handwritten circuit diagram → extract component values and connections as JSON), diagram explanation (photo of a Class 8 IoT wiring → explain what's connected and whether the resistors are correct), accessibility (describe a PREKSHA lab photo for a visually impaired student), assignment grading (student submits photo of handwritten code → GPT-4V checks for syntax errors and logic issues). Implementation: the image is base64-encoded and included in the messages array alongside text. Token cost: a 512×512 image costs ~170 tokens. A detailed image at 1024×1024 costs ~765 tokens. Students build the multi-modal assignment helper: teacher uploads photo of student's handwritten circuit, prompt asks "Check if the resistor values are correct given a 5V supply and standard LEDs. Explain any errors clearly for a 13-year-old." — directly useful in the PREKSHA lab.

The EU AI Act (2024) classifies AI systems by risk. High-risk: education and vocational training (directly affects student outcomes). AI systems in education must: provide transparency to users that they're interacting with AI, ensure human oversight of automated decisions, maintain audit logs of all interactions, allow users to challenge automated outputs. The PREKSHA AI Study Assistant qualifies as high-risk — it directly affects students' understanding of curriculum. Requirements students must implement: system prompt disclosure ("I'm an AI assistant for PREKSHA curriculum — I may make mistakes"), clear citation of source documents, teacher oversight dashboard showing which questions were asked and answered, anomaly detection (alert if a student's query pattern suggests academic dishonesty), rate limiting (prevent students from using the AI to complete assignments wholesale rather than learn).

The Class 12 AI grand capstone integrates all three years of AI/ML learning: Document ingestion: 7 years × 3 tracks × 3 terms × topic descriptions = 63 curriculum units + all PREKSHA project descriptions → LangChain PDF/text loader → recursive text splitter (512 tokens, 50 overlap) → OpenAI ada-002 embeddings → Pinecone upsert. Query pipeline: embed question → Pinecone hybrid search (top-20) → Cohere reranking (top-5) → GPT-4o with source citation prompt → stream via FastAPI SSE → render in Next.js chat UI with source drawer. Memory: ConversationBufferWindowMemory (last 6 turns). Multi-modal: student can upload circuit diagram photo → GPT-4V answers questions about it → answer stored in conversation history. Teacher analytics: track which curriculum topics are queried most frequently → identify knowledge gaps → inform next year's teaching focus. RAGAS evaluation suite: 50 test Q&A pairs covering all 7 classes, run on every code change via CI/CD. Target: Faithfulness >0.85, Answer Relevancy >0.82. Full CI/CD: GitHub Actions → pytest → RAGAS eval → deploy to Railway (FastAPI) + Vercel (Next.js).

The AI Study Assistant is pitched to PREKSHA Academy management as a real product for real adoption in 2027. Pitch deck: (1) Problem — "PREKSHA Class 6 students spend 45 minutes per week looking for specific curriculum explanations across notes, the website, and asking teachers. This wastes 22.5 hours of learning time per student per year." (2) Solution — live demo of the chat assistant answering a Class 6 question about HTML, with citations. (3) Technical architecture — one diagram, explained in 3 minutes. (4) Quality metrics — RAGAS Faithfulness 0.87, Answer Relevancy 0.84 — shown as a chart across iterations. (5) Cost model — OpenAI API cost: ₹0.32 per student per month at 50 queries/month. Pinecone free tier covers 1M vectors. Total cost: ₹0.32 × 500 students = ₹160/month. (6) Adoption plan — Class 6 pilot (lowest stakes, most benefit), expand after one semester. (7) Safeguards — teacher override dashboard, EU AI Act compliance checklist. Management votes yes/no on adoption. The most meaningful assessment of the year: a real product decision by real stakeholders.