Theme: Cybersecurity
Problem 1 — Automated Threat Hunting & Response in Hybrid Environments
Short description: 

Design an automated system to detect, investigate, and respond to zero-day and advanced threats across hybrid environments (on-premise + cloud). The system should combine anomaly detection, behavioral analytics, and threat intelligence to contain threats or produce detailed incident reports automatically.

Requirements:

  • Continuous monitoring across hybrid resources (on-premise and cloud).
  • Multi-modal detection pipeline: anomaly detection + behavior analytics + threat intelligence integration.
  • Automatic containment actions were feasible (e.g., isolate the host, revoke credentials), and high-quality incident reports were created when a manual response was required.
  • Capability to handle encrypted traffic, stealthy lateral movement, and privilege escalation attempts.
Problem 2 — Phishing Detection and User-Awareness Simulator
Short description: 

Build a platform that detects phishing emails/URLs and simulates controlled phishing campaigns to evaluate and improve user awareness. The system should report user risk scores, common failure points, and recommend training resources.

Requirements:
  • Classifier for phishing vs. benign emails/URLs.
  • Safe simulation platform to send internal phishing tests (configurable and opt-in).
  • Dashboard reporting user vulnerability metrics (e.g., click-through rate, interaction paths) and individual risk scores.
  • Automated recommendations for remediation and training content (videos, quizzes, short modules).
  • Focus on UX and ease of deployment.
Problem 3 — Secure Mobile App Supply-Chain Vulnerability Scanner
Short description:

 Create a tool that analyzes mobile app packages (APK/IPA) or build manifests to detect vulnerable dependencies, insecure API usage, misconfigurations, and provide actionable remediation guidance to developers.

Requirements:
  • Parse APK/IPA files or build system manifests to extract dependency graphs.
  • Match dependencies against known CVEs and unsafe behavior indicators.
  • Static analysis checks for insecure practices (e.g., plaintext storage of secrets, insecure network calls, weak crypto, incorrect permissions).
  • Provide remediation guidelines and best-practice recommendations.
  • (Optional) Analyze API endpoints used by the app and warn about TLS/certificate validation weaknesses.
Problem 4 — Password Leak Checker & Credential Safety Advisor
Short description:

 Build a privacy-first service that lets users check whether their email or username appears in known breach databases and provides practical guidance to improve credential safety (strength meter, 2FA suggestions, password manager recommendations).

Requirements:
  • Query publicly available breach datasets (or a simulated dataset for demo).
  • Simple web interface or CLI that accepts email/username inputs only (do not require password inputs).
  • Password strength meter for user-created passwords (client-side evaluation recommended).
  • Suggestions to enable multi-factor authentication (when applicable) and guidance on using password managers.
  • Clear privacy guarantees: no sensitive inputs stored or logged.
Problem 5 — Local Network Device Discovery & Vulnerability Alert Tool
Short description:

 Develop a lightweight tool for home or small-office networks that discovers connected devices, detects open ports/services, checks for common vulnerabilities (e.g., default credentials, outdated firmware), and alerts users with prioritized mitigation steps.

Requirements:
  • Device discovery via network techniques (IP scan, mDNS, SSDP, ARP, etc.).
  • Port/service identification and version fingerprinting, where possible.
  • Cross-check discovered services against a vulnerability database (or curated rule set).
  • Simple UI showing device risk levels and suggested mitigations (change default passwords, update firmware, disable insecure services).

Theme: AR/VR

Problem 1 — Secure & Adaptive Mixed Reality Collaboration Platform

Short description:
 Build a secure, real-time mixed-reality collaboration platform where AR and VR users join the same shared session to interact, share virtual objects, and annotate spaces. The system must adapt rendering to device capabilities while preserving privacy, identity, and resilience against MR-specific attacks.

Requirements:
  • Support AR clients (mobile / AR glasses) and VR headsets in a shared session.
  • Deterministic synchronization of shared objects and annotations.
  • Adaptive rendering/environment scaling per device capability.
  • End-to-end encryption, participant identity verification, and role-based permissions.
  • Mitigations for MR threats: sensor spoofing, motion-data leakage, malicious avatars, and tampering.
Problem 2 — Motion Sickness & Comfort Optimization Module for VR/AR Experiences

Short description:
 Design an engine or plugin that monitors user comfort in real time (telemetry and heuristics) and dynamically adjusts rendering/interaction to reduce motion sickness, fatigue, and eye strain while preserving immersion.

Requirements:
  • Collect telemetry: head motion, rotation speed, frame latency/drops, session time.
  • Detect discomfort via heuristics, optional user feedback, or physiological sensors if available.
  • Dynamically adjust parameters: FOV, motion blur, visual complexity, movement speed, or suggest breaks.
  • Developer dashboard with metrics showing adjustments and comfort outcomes.
  • Demo with sample scenes (fast, slow, mixed motion) and measurement of improvement.
Problem 3 — AR Campus Guide / Tour App with Contextual Info

Short description :
 Build an AR mobile campus guide: point a phone at buildings/landmarks to show contextual overlays (history, schedules, occupancy, announcements) with a simple admin backend for staff updates.

Requirements:
  • Use ARCore/ARKit or a cross-platform tool to detect image targets, markers, or geolocated spots.
  • Stable, legible overlays (text/images) adaptable to lighting/occlusion.
  • Admin backend for staff to publish notices, schedules, and occupancy.
  • Polished UI/UX and reliable target detection.
Problem 4 — Interactive VR Training Simulation for a Simple Task

Short description :
Create an interactive VR simulation for a practical task (e.g., equipment assembly, safety procedure) with progressive difficulty, immediate feedback on errors, and performance tracking so users can safely practice before doing the real task.

Requirements:
  • At least two levels/complexities and one or more error scenarios.
  • Real-time feedback and corrective guidance for mistakes.
  • Performance metrics: time, errors, and completion rate.
  • Intuitive controls and clear in-VR instructions                                       

  Theme:  IoT

Problem 1 — Trustworthy & Autonomous IoT Device Lifecycle Security Platform

Short description:
 Build a platform that secures IoT devices across their entire lifecycle — manufacture → deployment → operation → decommission. The system should provide secure boot, firmware verification, OTA updates, remote attestation, device identity management, and lightweight anomaly detection suitable for constrained devices.

Requirements:
  • Secure Boot / Root of Trust: ensure only manufacturer-signed firmware executes.
  • Remote attestation: periodic or on-demand integrity proofs from device to server.
  • Secure OTA updates: integrity checks, rollback safety, version control, authenticated updates.
  • Device identity & access control: unique identity, secure enrollment/registration, secure decommissioning/revocation.
  • Lightweight telemetry/anomaly detection for tampering, misconfiguration, or unauthorized behavior.
  • Design for constrained devices: low CPU, memory, battery, intermittent connectivity.
Problem 2 — IoT Botnet Detection & Mitigation in Smart Home Networks

Short description:
 Design a home-network monitoring system that detects IoT devices behaving maliciously (or as part of botnets) and automatically mitigates risk by isolating devices, blocking suspicious traffic, and notifying the owner.

Requirements:
  • Network traffic monitoring and feature extraction for IoT device flows.
  • Behavioral baselines per device type (or per-device) to detect deviations.
  • Detection of anomalies / malicious patterns (e.g., scanning, high outbound traffic, suspicious C2 connections).
  • Automated mitigation: quarantining devices, blocking flows, or rate-limiting.
  • User-facing UI showing which device misbehaved and recommended actions (change password, update firmware, factory reset).
Problem 3 — Default Credentials Auditor & Config Hardener for IoT Devices

Short description :
 Build a network utility that discovers IoT devices, checks for default/weak credentials across common interfaces (web/telnet/SSH), and helps users remediate by suggesting or automating credential changes where safe.

Requirements:
  • Local network device discovery (mDNS, SSDP, ARP, etc.).
  • Check authentication interfaces for known default credentials and weak passwords (read-only reporting unless explicit admin consent).
  • Report findings and provide secure credential suggestions or guided steps to change them.
  • Clear privacy and safety measures: do not perform harmful actions or store sensitive credentials.
Problem 4 — Firmware Update Reminder & Patch Tracker App for IoT Devices

Short description :
 Create a mobile or web app that inventories IoT devices in a home or small business, tracks firmware versions and advisories (CVE/patch status), and notifies users when updates or security patches are available, along with update instructions.

Requirements:
  • Catalog devices via scan or manual entry and maintain a device inventory.
  • Maintain or reference a database of firmware versions and known advisories (CVE feeds or curated dataset).
  • Notify users about out-of-date devices and known vulnerabilities affecting their versions.
  • Provide step-by-step guidance or links for updating devices.

Theme: Agentic AI 

Problem 1 — Agentic AI Voice Assistant for Customer Service & Appointment Scheduling

Short description:
 Build an agentic voice assistant that autonomously handles inbound customer voice calls (demo on WebRTC), answers FAQs by fetching live business data, schedules and reschedules appointments, maintains multi-turn context and memory, logs call summaries, and escalates to humans when needed.

Requirements:

  • Real-time speech-to-text + LLM reasoning pipeline for multi-turn dialogs.
  • Integrate with business data sources (APIs / KB) to fetch products, pricing, hours, and policies.
  • Calendar integration (Google/Outlook/custom) with slot checking, booking, rescheduling, and double-book prevention.
  • Persistent short-term memory for the call and optional longer-term memory to avoid repetition.
  • Call logging and autogenerated summaries for staff (who called, intent, scheduled items, unresolved issues).
  • Graceful failure: escalate to a human operator or create a ticket when needed.
  • Design for future extension to mobile/SIM calls.
Problem 2 — Multi-Agent Task Coordination for Office Automation

Short description:
Create a multi-agent system that automates office workflows (meeting scheduling, email summarization, report generation, task routing). Agents should coordinate via shared context and handle conflicts, integrations, and user overrides.

Requirements:
  • Role-based agents (e.g., meeting agent, mail summarizer, report generator, task router).
  • Shared context/memory so agents know schedules, deadlines, and commitments.
  • Conflict detection and resolution logic (overlapping meetings, deadline clashes).
  • Integrations with calendars, email, chat, and project management tools.
  • Monitoring and feedback loop: user corrections, override options, and satisfaction metrics.
Problem 3 — Agentic AI for Personal Finance Assistant

Short description:
 Build an agentic assistant that ingests transaction data (real or simulated), tracks spending, forecasts expenses, recommends savings/optimizations, and explains its recommendations with clear reasoning and confidence indicators.

Requirements:
  • Ingest transactions from bank/card feeds or simulated datasets.
  • Persistent memory of user preferences, recurring expenses, and goals.
  • Forecasting tooling and scenario simulation (e.g., impact of canceling subscriptions).
  • Explainability: show what data led to suggestions and confidence levels.
  • Strong data privacy and security practices for sensitive financial info.
Problem 4 — Agentic Reminder Assistant with Smart Context

Short description :
 Design a context-aware reminder agent that schedules and nudges users intelligently—considering calendar, location, weather, and past behavior—to decide the best time or whether to postpone reminders.

Requirements:
  • Memory of past reminders and user responses (completed, snoozed, ignored).
  • Inputs: calendar access and optional location or weather data.
  • Decision logic: avoid reminders during meetings, postpone outdoor tasks if raining, and prioritize critical tasks.
  • Simple UI for creating reminders and feedback (done, snooze, dismiss).

Problem 5 — Agentic AI Chatbot for FAQ + Ticketing Duties

Short description :
 Implement an agentic FAQ chatbot that answers common queries and automatically opens support tickets when it cannot resolve an issue; maintain ticket status and learn to suggest new FAQs over time.

Requirements:
  • Searchable FAQ/knowledge base with a retrieval mechanism.
  • Low-confidence detection that triggers ticket creation (can be simulated).
  • Memory to track tickets, status, and user feedback on responses.
  • Chat or web UI for interaction and ticket tracking.
  • Learning loop: propose new FAQ entries based on recurring tickets.

Theme: Bitcoin 

Problem 1 — Privacy-preserving Bitcoin Payment Channels with On-chain Fallback & Auditability

Short description:
 Design an off-chain payment channel system (Lightning-style) with stronger privacy guarantees (obfuscated linkages, hidden amounts), secure on-chain fallback for disputes, and auditability for authorized auditors without breaking user privacy. Include routing, fee mechanics, and robust failure handling.

Requirements:
  • Off-chain payment channels supporting high throughput, low fees, and low latency.
  • Enhanced privacy: hide linkability between payments and optionally amounts (ZK or other techniques).
  • Secure on-chain fallback/settlement mechanism for disputes; verifiable and non-repudiable.
  • Auditor-friendly protocol: authorized auditing (or cryptographic logs) that verify totals/correctness without exposing private user linkage.
  • Route payments through intermediary channels with fee rules while preserving privacy of the path and amounts.
  • Defend against malicious intermediaries and ensure funds cannot be locked indefinitely (timeouts, penalty mechanisms).

Stretch / Bonus features:

Zero-knowledge proofs for amounts/path hiding, dynamic channel rebalancing, incentive mechanisms for routing nodes, and workload/stress simulation.

Problem 2 — Intelligent Fraud Detector for Bitcoin Transactions / Exchanges

Short description:
 Build a system to monitor Bitcoin transaction flows (exchange/wallet level or simulated) and detect suspicious/fraudulent behavior (mixing, laundering patterns, abnormal velocity), assign risk scores, visualize flows, and recommend actions.

Requirements:
  • Ingest blockchain data, mempool events, and (optionally) exchange/wallet logs or simulated feeds.
  • Feature engineering: address clustering, graph features, temporal patterns, chain-splitting heuristics.
  • ML or rule-based anomaly detection that flags suspicious flows and assigns a risk score + rationale.
  • Visualizations of flagged flows and affected addresses.
  • Optional integration with on-chain watchers/alerts for real-time monitoring.
Problem 3 — Secure Lightweight Bitcoin Wallet with Social Recovery & Multi-device Sync

Short description:
 Create a user-friendly Bitcoin wallet (mobile/web) that supports social recovery (recover access via trusted parties without exposing private keys), multi-device sync of state/history, offline/cold signing, and good UX for everyday users.

Requirements:
  • Social recovery scheme (threshold schemes, smart-contract-assisted, or other approaches) that resists collusion and MIM attacks.
  • Multi-device synchronization for transaction history/state without exposing private keys or relying on fully-trusted central servers.
  • Offline/cold signing workflow and support for hardware wallets / external signers.
  • Usability features: balance, history, fee estimation, and QR code flows.
  • Safety nets: conflict resolution for stale states, handling chain reorganizations.
Problem 4 — Bitcoin Price Alert & Prediction Dashboard

Short description :
 Build a dashboard that displays real-time Bitcoin prices and historical charts, lets users set alerts and receive notifications, and provides short-term price predictions (hourly/day) with confidence metrics and optional news-sentiment correlation.

Requirements:
  • Real-time price feed and historical charting UI.
  • User-configurable alerts (price thresholds, percent moves) with notification channels.
  • Short-term prediction models (time-series / ML) and confidence/metrics for predictions.
  • (Optional) News sentiment overlay correlated with price moves.                       

Theme: Robotics & Drones 

Problem 1 — Autonomous Drone Delivery System for Last-Mile Under Constraints

Short description:
 Build a prototype (simulation or small physical) for last-mile drone delivery that plans and executes deliveries under constraints like no-fly zones, battery limits, payload effects, and environmental disturbances.

Expected features:
  • Map with obstacles / no-fly zones and altitude restrictions.
  • Path/trajectory planning and route optimization.
  • Payload/weight modeling affects battery drain and flight time.
  • Safe takeoff/landing detection (camera/sensors).

UI for scheduling multiple delivery requests.
Stretch goals:

Weather/wind adaptation, dynamic rerouting for new requests, and payload-securement sensing.

Problem 2 — Warehouse Robot for Picking & Sorting with Vision + Manipulation

Short description:
 Create a ground robot with a manipulator (or simulated arm) that uses vision to identify items on a conveyor/storage, picks and sorts them into bins, and handles errors in real time while optimizing throughput.

Expected features:
  • Vision pipeline for object detection/classification and pose estimation.
  • Motion/path planning for base and manipulator.
  • Gripper or mechanism to handle varying shapes/sizes.
  • Real-time error handling (mis-grasp, dropped item).Batch handling and optimization to minimize time/travel.

Stretch goals:Adaptive grip force, learning from mistakes to reduce errors, handling moving obstacles/human interference.

Problem 3 — Self-Charging / Docking Ground Robot for Routine Tasks

Short description :
 Build a robot that autonomously returns to a docking station to recharge and resumes its routine task (patrol, cleaning, monitoring). Simulation or physical prototype accepted.

Features:
  • Battery monitoring and threshold-based return behavior.
  • Reliable navigation to docking (marker/beacon/vision/localization).
  • Resume task after recharge with state persistence.Basic obstacle avoidance en route.

Stretch goals:Robust docking mechanics, handling blocked dock scenarios, and visual feedback of robot state.

Problem 4 — Drone for Aerial Inspection & Obstacle Alert System

Short description :
 Implement a drone (real or simulated) that follows predefined aerial routes for inspection (buildings, towers, pipelines), detects anomalies/obstacles using sensors, and alerts users with logs and media evidence.

Features:
  • Waypoint-based flight path programming.
  • Live camera feed and optional depth/ultrasonic/LiDAR sensors.
  • Anomaly/obstacle detection and logging (image + coordinates).
  • An alerting system that notifies users and stores inspection snapshots.

Stretch goals:ML-based damage classification (cracks, rust), automatic reroute if obstructed, and auto-generated inspection reports.

Theme: EdTech

Problem 1 — Fair & Scalable AI-Driven Assessment + Feedback System for Diverse Learners

Short description:
 Design an AI system that automatically assesses written student work (essays, short answers) and generates personalized, actionable feedback while ensuring fairness, transparency, and support for diverse linguistic and cultural backgrounds.

Requirements:
  • Multi-language / dialect support for input and evaluation.
  • NLP + LLM-based scoring for content correctness, coherence, clarity, and grammar.
  • Rich feedback: organization, vocabulary, structure, and revision suggestions (not only a grade).
  • Bias analysis and mitigation (avoid penalizing non-standard English or cultural expression).
  • Human-in-the-loop dashboard for teachers to review/adjust feedback and override scores.

Analytics: track student progress over time, class-level weak points, and aggregate reports.
Stretch/bonus features:Adaptive feedback that focuses on repeated mistakes, plagiarism/originality checks, and an offline/lightweight mode for low-connectivity areas.

Problem 2 — Hybrid Learning Planner & Analytics Tool for Teachers

Short description:
 Create a teacher-facing tool to design hybrid lessons (online + offline), track student engagement across both modes, and provide actionable insights to adjust lesson plans and support at-risk students.

Requirements:
  • Lesson-planning interface that composes online/offline activities, quizzes, and projects.
  • Consolidated tracking of student progress across sources (LMS, quizzes, manual inputs).
  • Alerts/identification of students falling behind and where (online vs. offline gaps).
  • Recommendation engine to suggest targeted interventions (extra practice, flipped-classroom steps).
  • Dashboards/reports for teachers and, optionally, parents or students.
Problem 3 — Student Motivator & Habit-Builder App for Learning Routines

Short description :
 Create a simple app to help students build study habits—set goals/schedules, send reminders, track streaks, and use light gamification to encourage consistent learning.

Requirements:
  • Goal and schedule creation (daily/weekly targets).
  • Reminder system (notifications or email) and tracking of completion.
  • Visual progress (calendar, streaks, progress bars).
  • Gamified elements: badges, levels, friendly competition.
  • Feedback suggestions when users miss goals (adjust plan, suggest micro-tasks).
Problem 4 — Concept Visualization / Interactive Simulations

Short description :
 Build interactive visualizations or simulations for challenging topics (Physics, Math, Biology) that let students tweak parameters and observe real-time results, helping them form intuition and test hypotheses.

Requirements:
  • Choose 1–2 difficult topics and implement interactive simulations (web canvas / WebGL / Unity / JS).
  • Allow parameter manipulation (e.g., initial velocity, force, diffusion rate) with instant visual feedback.
  • Provide explanatory overlays and step-by-step walkthroughs.
  • Include a light assessment: let students predict outcomes, then test and reflect.
  • Ensure accuracy of underlying models and smooth UI/UX.

Theme: Women’s Safety 

Problem 1 — Proactive Safety Network + AI-Driven Prevention System

Short description:
 Design a proactive safety platform that predicts high-risk situations and helps users avoid them (rather than only reacting to incidents). Use environmental, temporal, crowdsourced, and device sensor signals to build a privacy-preserving risk map and provide safer-route / behavioral suggestions.

Requirements:
  • Collect contextual signals: time of day, historical incident density by location, lighting (camera/feedback), crowd density (public feeds or user input), transit/transport patterns.
  • Crowdsourced anonymous reporting with moderation and reputation controls to build a community risk map.
  • ML model to predict route/segment risk and propose safer alternatives or preemptive actions.
  • Proactive alerts when the user is about to enter a high-risk zone/time with recommended actions (alternate route, companion, avoid).
  • Offline caching / local risk map slices so functionality works with intermittent connectivity.
  • Strong privacy & safety: anonymize reports, protect location/identity, allow opt-in/opt-out, audit logs to detect misuse.
Problem 2 — Smart Wearable + App Hybrid for Silent SOS & Evidence Recording

Short description:
 Build a discreet wearable + mobile app system to silently trigger alerts and securely record evidence (audio/video/location) when a user is threatened—while minimizing detectability and preserving privacy and battery life.

Requirements:
  • Subtle trigger mechanisms: covert gesture, hidden button, innocuous voice phrase.
  • On trigger: encrypted capture of audio/video snippets, periodic GPS snapshots, and secure transmission to trusted contacts or a server.
  • Local encrypted storage + controlled upload to preserve privacy; UI for playback and evidence export.
  • Low-battery, permission-safe operation (works with locked screen, low-power modes).
  • Anti-accidental-trigger handling and review/confirm flow for false alarms.
Problem 3 — Onboarding & Resource Guide + Panic Button for Local Women Safety Services

Short description :
 Build a mobile/web app that aggregates local women’s safety resources (helplines, shelters, hospitals, police), shows them on a map, offers safety tips, and includes a panic button that alerts preset contacts with location.

Requirements:
  • Map of local resources: helplines, police stations, shelters, hospitals.
  • Emergency numbers and quick actions (call/SMS/share location).
  • Large, prominent SOS/panic button that sends message + GPS to trusted contacts; optional auto-call.
  • Safety tips library (street harassment, first-aid, reporting steps).
  • Offline/minimal-data support for core features and a clear privacy policy.
Problem 4 — Route Safety Visualizer & “Pre-Walk” Check for Women

Short description :
 Create a route-safety tool where a user inputs a planned walk and receives a visual safety assessment (unsafe segments, lighting, foot traffic, past reports) plus suggested safer alternatives and on-route imagery where available.

Requirements:

  • Route input (start/end) and visualization of safety metrics per segment (crowd density, lighting, incident history, user ratings).
  • Alternative route suggestions prioritized by safety, with tradeoffs (time/distance).
  • Integration with street imagery (Street View) or user-submitted photos for context.
  • Post-walk rating/reporting by users to improve the dataset.

Theme: WEB 3.0

Problem 1 —  Decentralized Medical Record Access & Consent Management

Short description :
 Create a blockchain-based platform where patients control access to their medical records, with real-time smart contract–enabled consent revocation for hospitals, insurers, and research labs. Use zero-knowledge proofs to verify data validity without revealing full patient history.

Requirements :
  • Integration with hospital EHR systems and IPFS/secure off-chain storage.
  • Smart contracts for consent granting/revocation with timestamp logging.
  • Zero-knowledge proof mechanism to verify a patient’s eligibility for insurance claims without revealing full medical records.
  • Secure QR-code-based access for emergency scenarios.
Problem 2 —   Web3-Based Farmer Co-op Market with AI Credit Scoring

Short description :
  Build a decentralized farmer marketplace where produce sales, payments, and AI-driven credit scores for microloans are handled via blockchain transactions.

Requirements :
  • Smart contracts to ensure timely payment to farmers.
  • AI-based credit scoring model trained on yield history, consistency, and past transactions.
  • Mobile-first design for rural usability with low-bandwidth optimization
  • Tokenized rewards for sustainable farming practices.
Problem 3 — Decentralized Transportation Logistics & Carbon Tracking

Short description:Create a blockchain+IoT system for real-time tracking of supply chains in urban transportation fleets, logging CO₂ emissions automatically with incentives for eco-friendly driving.

Requirements:
  • IoT hardware integration to measure fuel efficiency and emissions.
  • Smart contract–driven carbon credit rewards.
  • tamper-resistant ledger for route and load verification.
  • AI optimization for route planning to minimize emissions.

  Theme: Healthcare

Problem 1 — AI-Driven Mental Health Chatbot with Crisis Routing

Short description:Develop a chatbot that leverages sentiment analysis to detect levels of distress and route high-risk users to licensed counselors or emergency contacts.

Requirements

  • NLP sentiment & tone detection.
  • Integration with verified mental health professionals.
  • Crisis escalation protocol using predefined triggers.
  • Multi-language capability for inclusivity.
Problem 2 — Wearable-Integrated Predictive Health Alert System
Short description:

 Build a wearable+AI system that predicts early health deteriorations (e.g., heart failure, respiratory distress) and automatically shares reports with healthcare providers.

Requirements:
  • Integration with existing wearable sensors (SpO₂, ECG, body temp).
  • AI prediction using patient history + real-time vitals.
  • HIPAA/GDPR-compliant data transmission.
  • Emergency alert support with patient GPS.
Problem 3 — Hospital Resource Optimization via Federated AI 

Short description:Create a federated learning system for hospitals to share AI models (not raw data) to predict bed occupancy, oxygen needs, and medicine shortages during outbreaks.

Requirements:
  • Federated AI pipeline with differential privacy.
  • Multi-hospital data model training without data sharing.
  • Resource allocation dashboard for authorities.
  • Scenario-based outbreak simulation

Theme: Agriculture

Problem 1 — AI Crop Disease Classifier with Farmer Voice Queries 
  Short description:

 Build a mobile tool for farmers to take plant pictures and get instant diagnosis + treatment tips, supporting offline mode and voice queries in local languages.

Requirements:
  • Image-based disease detection using trained ML models.
  • Offline ML inference.
  • Multi-language and voice-based query interface.
  • Localized treatment recommendations.
Problem 2 — IoT-Driven Smart Irrigation with Rainfall Prediction 
Short description:

 Develop an IoT irrigation system that uses soil moisture, temperature, and AI-based weather predictions to manage water use efficiently.

Requirements:
  • IoT sensors for soil and climate data.
  • AI rainfall prediction using historical + current data.
  • Smart valve control.
  • Water usage logs stored on blockchain for subsidies
Problem 3 — AI-Blockchain Hybrid for Farm-to-Fork Traceability
Short description:

 Build a farm produce traceability solution where every batch’s origin, handling, and transport are logged on blockchain, with AI detecting spoilage risks in transit.

Requirements:
  • IoT temperature/humidity sensors in logistics.
  • Blockchain ledger for product lifecycle.
  • AI spoilage risk detection using logistics data.

Consumer-facing QR scan to view full journey.                 

Theme: Sustainable Energy

Problem 1 — Microgrid Energy Trading App
Short description:

 Build an app for communities to trade surplus solar energy in real time, with automatic payments powered by smart contracts.

Requirements:

  • Smart contract energy trade matching.
  • Energy meter integration via IoT.
  • Transaction simulation feature for non-tech users.
  • Leaderboards for top green contributors.
Problem 2 — AI-Powered Dynamic Energy Demand Shaper 
Short description:

 Develop an AI system that forecasts energy consumption and automatically shifts appliance usage (HVAC, EV chargers) to off-peak times using IoT.

Requirements:

  • AI demand prediction model.
  • IoT appliance control API.
  • Integration with utility company tariffs.
  • User override and scheduling.
Problem 3 — Blockchain-Based Renewable Energy Certificate Marketplace
Short description:

 Create a secure marketplace for individuals and companies to trade renewable energy certificates backed by IoT-verified production.

Requirements:
  • IoT sensors at renewable generation sites.
  • Smart contracts for certificate issuance and transfer.
  • Double-spending prevention.
  • Cross-border trading support.

 Theme: Transportation

Problem 1 — AI-Powered Smart Parking Finder 
Short description: 

Build an AI app that predicts and guides drivers to nearest available parking spots, considering historical occupancy and live sensor data.

Requirements:
  • Parking lot IoT sensors/CCTV data integration.
  • AI occupancy forecasting.
  • Navigation integration with Google/OSM APIs.
  • Payment gateway for spot booking.
Problem 2 — Driver Drowsiness & Distraction Monitoring Helmet 

Short description: Develop an AI+wearable solution for drivers and riders that detects drowsiness/distraction, alerts them, and sends emergency signals if required.

Requirements:

  • Camera + EEG/ECG sensor integration.
  • Computer vision drowsiness detection.
  • Vibration/audio alerts.
  • Cloud logging for accident analysis.
Problem 3 — Autonomous Drone-Based Emergency Traffic Clearance 

Short description:  Build a swarm drone control system that clears traffic routes for ambulances in dense cities by coordinating multiple UAVs in real time with law enforcement.

Requirements:
  • Drone swarming AI.
  • Real-time traffic pattern recognition.
  • Integration with emergency vehicle GPS.

Legal geo-fencing compliance.         

Theme: Smart Automation

Problem 1 — AI Home Energy Optimizer 

Short description: Create a home IoT system that learns user routines to optimize lighting, HVAC, and appliance power consumption.

Requirements:
  • Routine learning via usage pattern analysis.
  • Smart plug integration.
  • Mobile control dashboard.
  • Solar/battery integration support.
Problem 2 —Human-Centric Safety in Embedded Systems

Short description:Design an embedded solution that can detect and validate human readiness or presence before allowing a system to operate. Your solution should combine sensor inputs, real-time decision logic, and actuation control, ensuring that the system behaves responsibly based on environmental or user-specific factors.

Requirements:
  • Use multiple sensors to monitor human-related conditions (e.g., proximity, posture, environmental exposure).
  • Implement decision logic that evaluates sensor data to determine whether the system should activate or remain idle.
  • Provide clear feedback (visual, serial, or auditory) to indicate system status.
  • Ensure the system is fail-safe—it must default to a safe state if conditions are unclear or unsafe.
Problem 3 — AI-Powered Multi-Robot Coordination for Warehouses 

Short description:Create a multi-robot task allocation system for warehouses that minimizes travel distance and handles dynamic changes in priorities, integrating with ERP systems.

Requirements:
  • Multi-agent reinforcement learning.
  • Real-time obstacle avoidance.
  • ERP integration via APIs.
  • Failover strategies for robot downtime.