Design, Development and Project Management
Open in the Padhaiko app2.1 Design and development of major project (software/hardware/hybrid system)
During Project II, architectural sketches from Project I must mature into implementation-ready engineering designs. Whether your group is building a pure software platform, an embedded hardware device, or a hybrid edge-to-cloud system, sound design ensures modules fit together cleanly, scale under realistic loads, and remain testable throughout the semester.
Software, Hardware, and Hybrid Project Systems
- Software System: End-to-end digital application or research pipeline (web/mobile client, API backend, database, ML/AI inference engine, or simulation framework) running on general-purpose compute nodes or cloud servers.
- Hardware System: Physical electronic or embedded artifact built around microcontrollers, FPGAs, sensors, actuators, power regulation, signal conditioning, and custom PCBs or enclosures.
- Hybrid System: Integrated architecture coupling physical hardware sensing/actuation at the edge with networked software services, data pipelines, dashboards, or cloud-hosted ML models.
2.1.1 Architectural Artifacts Required Before Heavy Coding
Before writing production modules, finalize four core design artifacts and keep them synchronized with your codebase:
- System Architecture & Data-Flow Diagram: Show every component (clients, gateways, services, databases, model pipelines, physical sensors), the protocols connecting them (HTTP/REST, WebSocket, MQTT, SPI/I2C, UART), and trust/network boundaries.
- Database Schema or Data Contract: Define normalized relational schemas (ER diagrams, primary/foreign keys, indexes), time-series schemas, or strict JSON/Protobuf payload schemas—plus dataset directory/annotation schemas for Research Track projects.
- Interface & API Specification: Lock endpoint paths, request/response formats, error codes, and hardware pinout/register maps early so team members can build frontend, backend, and firmware in parallel without blocking each other.
- Hardware Schematic, Power Budget & Enclosure Plan (for hardware/hybrid systems): Document supply voltages (3.3 V vs. 5 V logic levels), peak current draw, battery/solar sizing, flyback/ESD protection, and physical wiring/PCB layout.
| Aspect | Software System Design | Hybrid / Hardware System Design |
|---|---|---|
| Primary Interfaces | REST/GraphQL APIs, IPC queues, database connections, UI states | GPIO, ADC/DAC, I2C/SPI/UART buses, RF links (Wi-Fi/BLE/LoRa), plus API/UI |
| Failure Modes | Null payloads, race conditions, DB deadlocks, memory leaks, OOM | Sensor drift, noisy ADC readings, brownouts, loose wiring, packet loss, thermal limits |
| Prototyping Speed | Rapid iteration via hot-reload, containers, and unit mocks | Slower iteration due to component lead times, soldering, flashing, and physical calibration |
| Design Safeguards | Input validation, schema migrations, idempotent endpoints, auth tokens | Voltage-level shifters, pull-up/down resistors, watchdog timers, offline ring buffers |
2.2 Application of programming skills, algorithms and engineering tools
A B.E. Major Project is evaluated not just on whether the demo runs, but on the engineering discipline behind the code, algorithms, and tooling.
2.2.1 Software Craftsmanship and Algorithmic Rigor
- Modular Architecture & Design Patterns: Apply appropriate patterns rather than one giant script—for example, MVC/layered architecture in web backends, Repository/Service separation for database access, Producer-Consumer queues for streaming telemetry, or State Machines for embedded firmware and multi-screen UIs.
- Algorithm Selection and Complexity Trade-offs: Justify why a chosen algorithm fits your constraints—time/space complexity, memory footprint on edge devices (e.g., MobileNet/quantized INT8 vs. heavy ViT), indexing strategies (B-tree vs. HNSW vector index), or signal filtering (Kalman/moving-average filters for noisy sensors).
- Defensive Coding & Reproducibility: Validate inputs at every boundary, handle timeouts and malformed files gracefully, eliminate magic numbers with configuration files, and fix random seeds plus dependency versions (
requirements.txt,package-lock.json,Cargo.lock, PlatformIOplatformio.ini) so results reproduce identically on any evaluator's machine.
| Tool Category | Practical Examples | Concrete Benefit in Project II |
|---|---|---|
| Version Control & Collaboration | Git + GitHub/GitLab (feature branches, Pull Requests, .gitignore for weights/secrets) | Prevents overwritten code, tracks per-member commits, enables safe rollback before defense |
| Containerization & Environments | Docker, venv/conda, PlatformIO | Eliminates "works on my laptop" failures during demos and supervisor reviews |
| Automated Quality & CI | pytest, unittest, Jest, GitHub Actions, ruff/eslint | Catches regressions automatically after merges |
| Experiment & Model Tracking | MLflow, Weights & Biases, structured CSV/JSON run logs | Keeps hyperparameters, dataset splits, and evaluation metrics organized for Chapter 5 |
| Hardware & Network Diagnostics | Multimeter, oscilloscope/logic analyzer, serial monitor, Wireshark, Postman/curl | Isolates physical bus/timing bugs or malformed HTTP/MQTT payloads in minutes |
main ──●─────────────────────●─────────────────────●── (always demo-ready)
\ / /
dev ●───●─────●───────●───────●─────────────●
/ / /
feat/api-auth ───●─────● /
feat/ml-infer ───────────────●────────●
fix/sensor-i2c ───────────────────────────────●2.3 Integration of concepts from different subjects of computer engineering
Examiners explicitly check whether a final-year B.E. project synthesizes knowledge across the four-year Computer Engineering curriculum rather than relying on a single tutorial framework. Mapping your engineering choices back to core subjects strengthens both your design and your viva defense.
| Core Curriculum Subject | Concrete Engineering Application in Project II | Example Viva Justification |
|---|---|---|
| Data Structures & Algorithms (DSA) | Spatial/trie indexing, priority queues, graph routing, dynamic programming, complexity analysis | "Using a min-heap priority queue reduced alert dispatch scheduling from O(N^2) to O(N log N)." |
| Database Management Systems (DBMS) | 3NF/BCNF normalization, composite indexing, ACID transactions, query plan tuning | "Composite indexing on (device_id, timestamp) cut telemetry range-query latency from 420 ms to 18 ms." |
| Operating Systems (OS) | Multithreading/async I/O, mutexes/semaphores, RTOS tasks, memory/process scheduling | "Separating frame capture and inference into producer-consumer threads with a bounded ring buffer prevented UI freezes." |
| Computer Networks & Cybersecurity | TCP/UDP, MQTT/HTTP, TLS encryption, JWT/OAuth2, RBAC, OWASP sanitization, rate limiting | "Payload signing and parameterized SQL queries prevent spoofing and injection on public endpoints." |
| Software Engineering & OOAD | UML diagrams, SDLC sprints, SOLID principles, unit/integration test suites, CI | "Interface abstraction allowed swapping the mock sensor feed for live serial data without changing business logic." |
| Microprocessors & Embedded Systems | Interrupts, DMA, timers, PWM, ADC calibration, I2C/SPI protocols, low-power sleep modes | "Hardware timer interrupts sample at a deterministic 100 Hz instead of jittery software delays." |
| AI, ML & Data Science | Feature engineering, class-imbalance handling, cross-validation, regularization, ablation | "Stratified k-fold validation and focal loss prevented majority-class bias on rare fault labels." |
2.4 Time management, resource management, work division etc.
Eighth semester passes remarkably fast because final report submission sits 3 weeks before semester end and final defense sits 2 weeks before semester end, with Presentation II at Month 2 right in the middle. Effective management of time, people, and resources prevents last-minute integration panic.
2.4.1 Backward-Scheduled Semester-8 Timeline
Start from the official ENCT 461 milestones and schedule backward:
- Weeks 1–2: Incorporate Project I feedback, finalize detailed design/schema, confirm dataset/hardware readiness, submit Progress Report & Presentation I.
- Weeks 3–8 (up to Month 2): Build all core modules, complete primary system integration or baseline + candidate model runs, begin unit and integration tests, submit Progress Report & Presentation II.
- Weeks 9–11: Freeze new features; run full validation, user acceptance testing (UAT), ablation/performance tuning, and comparative evaluation; draft Chapters 1–5 of the Final Report.
- Weeks 12–13 (3 weeks before end): Complete Chapter 6 & Abstract, run plagiarism/format check, obtain supervisor sign-off, and submit Final Project Report.
- Week 14 (2 weeks before end): Rehearse speaker handoffs, record backup demo video, prepare viva Q&A, and complete Final Defense and Demonstration.
Task / Milestone W1 W2 W3 W4 W5 W6 W7 W8 W9 W10 W11 W12 W13 W14
------------------------------------------------------------------------------
Project I Feedback & Design ██ ██
[M1] Report & Presentation I ▲
Core Modules / Experiments ██ ██ ██ ██ ██
System Integration & Unit Test ██ ██ ██ ██
[M2] Report & Presentation II ▲
Feature Freeze + Full Eval ██ ██ ██
Performance Tuning & UAT ██ ██
Final Report Drafting & Audit ██ ██ ██ ██
[M3] Final Report Submission ▲
Defense Rehearsal & Demo Prep ██ ██
[M4] Final Defense & Demo ▲2.4.2 Work Division, Resource Management, and Risk Mitigation
- Balanced Technical Work Division: Every member must write code/hardware/experimental work and author report sections for the modules they built. Use a shared issue tracker (GitHub Projects, Trello, or Notion) with weekly 1-week sprints and visible task owners.
- Resource Management: Budget cloud GPU hours, API credits, and physical hardware early. Always order spare sensors/regulators (burnt modules happen), maintain local cached dataset copies, and verify university lab compute quotas before Week 4.
- Integration-First Discipline: Merge into
devat least twice a week rather than waiting until Week 7 for a "big bang" integration night. Keep a Risk Register tracking top failure points (e.g., low UAT turnout, hardware shipment delay, dataset noise) with pre-agreed fallbacks.
Designing a Hybrid System Integrating Multiple Computer Engineering Subjects
A three-member group is building a Smart Cold-Chain Vaccine & Perishable Storage Monitor (hybrid hardware + software system). Show how they should structure the system design (Topic 2.1), pick engineering tools and algorithms (Topic 2.2), and explicitly integrate at least four core Computer Engineering subjects (Topic 2.3).
Define the three-layer hybrid architecture (Topic 2.1):
- Edge Hardware Layer: ESP32 microcontroller connected to a calibrated temperature/humidity sensor (SHT31 via I2C) and door-reed switch, powered by a Li-ion UPS circuit with a local microSD ring buffer for offline resilience.
- Communication & Backend Layer: Secure MQTT over TLS publishing telemetry every 30 seconds to a Mosquitto broker, ingested by a FastAPI service into PostgreSQL/TimescaleDB.
- Analytics & Client Layer: An isolation-forest / sliding-window threshold detector flagging cooling compressor drift, paired with a React monitoring dashboard and SMS/push alerts.
Select programming practices, algorithms, and tools (Topic 2.2):
- Firmware in C++ (PlatformIO) using a non-blocking finite state machine and exponential moving average filter to suppress transient door-open spikes.
- Backend in Python (FastAPI + Pytest) packaged in Docker Compose; Git feature branches with PR checks; multimeter and logic analyzer for I2C bus pull-up verification.
Map the design explicitly to Computer Engineering subjects (Topic 2.3):
- Microprocessors / Embedded Systems: Hardware timer interrupts and deep-sleep duty cycling extend battery backup during power cuts.
- Computer Networks & Security: MQTT QoS 1 guarantees at-least-once telemetry delivery over flaky Wi-Fi, while TLS client certificates prevent rogue sensor spoofing.
- Operating Systems: Asynchronous worker queues decouple MQTT ingestion from alert dispatching so slow SMS gateways never stall database writes.
- DBMS & AI/ML: Time-partitioned hypertable indexing speeds 30-day chart queries, while rolling Z-score + Isolation Forest separates genuine compressor failure from brief door openings.
The group separates the hybrid system into Edge (ESP32 + local ring buffer), Transport/Backend (MQTT/TLS + FastAPI + time-series DB), and Analytics/UI layers, enforces PlatformIO/Docker/Git tooling, and anchors hardware timers, QoS/TLS, async workers, and time-series anomaly detection directly in Embedded Systems, Networks, OS, DBMS, and ML concepts.
Building a Semester-8 Work Breakdown and Risk Plan Around Official Checkpoints
A two-member Research-Track group is developing a Low-Resource Nepali Fake News Classifier using Transformer Embeddings and Graph Features. At Week 2, their dataset is still uncleaned and they have only free-tier Colab GPUs. Design a realistic 14-week work division, resource plan, and risk mitigation strategy aligned with ENCT 461 checkpoints.
Divide technical ownership fairly across the two members:
- Member A (Data & Graph Pipeline Lead): Scraping/deduplication hygiene, manual verification of test labels, TF-IDF / fastText baselines, and source-domain co-sharing graph construction.
- Member B (Model Training & Evaluation Lead): Multilingual transformer fine-tuning (XLM-R / MuRIL), Graph Attention fusion layer, reproducible seed/logging harness, statistical significance & confusion-matrix analysis.
- Shared Ownership: Both review PRs, inspect error cases together, and author the report chapters matching their owned components.
Align tasks to ENCT 461 milestones and compute constraints:
- Weeks 1–2 (Presentation I): Lock clean train/val/test splits (preventing topic/URL leakage) and finish TF-IDF + Logistic Regression baseline.
- Weeks 3–8 (Presentation II at Month 2): Pre-extract and save transformer embeddings once (cutting GPU time drastically), train the fusion classifier, and present preliminary comparative scores vs. 2 baselines.
- Weeks 9–11: Run 3-seed ablations (text-only vs. graph-only vs. fused), error analysis on misclassified Nepali headlines, and draft Chapters 1–5.
- Weeks 12–14: Submit Final Report (Week 12/13, 3 weeks before end) and rehearse Final Defense (Week 14, 2 weeks before end).
Add concrete fallback actions in a Risk Register:
- Risk 1 (GPU session timeout mid-epoch): Save checkpoints every epoch to Google Drive and keep a lightweight Distil-mBERT/LoRA fallback configuration.
- Risk 2 (Noisy scraped labels): Manually audit a stratified sample of 400 test items by both members (measuring inter-annotator agreement) so test evaluation stays credible.
The two members split Data/Baselines and Model/Evaluation ownership evenly, conserve GPU quotas by caching frozen embeddings and running fast CPU baselines first, lock Month-2 and Week N-3 deadlines on a backward schedule, and mitigate GPU disconnects and noisy labels with epoch checkpointing and dual-audited test splits.
Viva-Style Questions: Design, Development and Project Management
Why should a software or hybrid system separate core domain/algorithmic logic from UI handlers, database drivers, and hardware GPIO calls during Project II design?
Testability and parallel development: When business logic or signal processing is decoupled behind clean interfaces, teammates can unit-test algorithms using deterministic mock inputs without needing live hardware sensors, external APIs, or clicking through UI screens.
Maintainability during mid-semester refinements: If Presentation II examiners ask to swap a database engine, change an ML model, or replace a broken sensor module, decoupling isolates the change to one adapter layer rather than breaking the entire codebase.
Decoupling core logic from I/O and UI makes modules independently unit-testable, enables parallel team development, and isolates hardware, API, or model swaps without rewriting the whole system.
Give three concrete ways a Project II group demonstrates "integration of concepts from different subjects of computer engineering" rather than just stitching together a third-party tutorial.
Connect design choices to specific curriculum principles:
- DBMS + Algorithms: Designing normalized tables with targeted composite indexes and justifying query speedups using B-tree/complexity reasoning.
- OS + Embedded/Software Engineering: Using non-blocking I/O, producer-consumer queues, or hardware timer interrupts with mutex protection instead of polling loops that freeze execution.
- Networks + Security: Securing client-server or IoT communication with TLS, token expiry, RBAC, and input validation rather than sending plain unauthenticated HTTP/MQTT packets.
A group demonstrates curriculum synthesis by applying DBMS normalization/indexing, OS concurrency/interrupt handling, and Network security/protocol guarantees—backed by measurable engineering trade-offs rather than default framework boilerplate.
What is wrong with dividing a three-member Project II team into "Member 1: Frontend, Member 2: Backend, Member 3: Documentation & PPT"?
Technical parity and viva risk: In ENCT 461, every B.E. graduate is assessed individually on engineering design, implementation, and technical mastery. A student assigned solely to "documentation and slides" cannot answer technical questions on architecture, algorithms, or code during Presentation II or Final Defense, hurting both their individual evaluation and the team's credibility.
Balanced alternative: Assign every member ownership of at least one substantive technical module (e.g., Data/ML pipeline, Backend/Database, Frontend/Testing harness) and have each member document the design and test results of the module they built, with one member coordinating final report assembly and formatting.
Assigning one member solely to documentation fails individual engineering assessment in viva and leaves that member unable to defend the system. Every member must own a technical module and author its matching documentation.
How should a Project II Gantt chart be anchored to the official ENCT 461 calendar, and what happens if integration starts only two weeks before final report submission?
Official anchor dates: The Gantt chart must work backward from four fixed syllabus gates: Presentation I (Week 2), Presentation II (Month 2), Final Report Submission (3 weeks before semester end), and Final Defense (2 weeks before semester end).
Consequence of late integration: Waiting until two weeks before report submission to connect modules leaves zero time for integration debugging, performance evaluation, user testing, or writing Chapter 5 (Results & Discussion). All major modules must integrate before Month 2 (Presentation II), leaving the post-Month-2 window for testing, optimization, and thesis writing.
Anchor the schedule to Week 2, Month 2, End minus 3 weeks, and End minus 2 weeks, ensuring core integration finishes by Month 2; late integration collapses testing, evaluation, and Chapter 5 writing time.
A hardware-based project group discovers in Week 5 that a specialized sensor ordered from abroad is delayed by four weeks. What project management and technical practices keep them on track for Presentation II?
Decouple software/cloud progress from physical hardware: Build a hardware abstraction layer and synthetic sensor simulator (replaying realistic noisy serial/MQTT streams) so the backend, database, anomaly detection, and dashboard proceed unimpeded.
Use a local substitute sensor and update the risk log: Wire a readily available local substitute (e.g., a standard DHT22/potentiometer testbed) to validate microcontroller ADC/I2C timing, power budget, and PCB pinouts immediately, then document the mitigation transparently in Progress Report II until the final sensor arrives for calibration.
Use a hardware abstraction layer with simulated data streams plus an available local substitute sensor to test MCU interfaces, backend, and UI on schedule while logging the procurement delay and calibration plan in the risk register.