Design, Development and Project Management
Open in the Padhaiko app3.1 Design and development (Software/hardware/hybrid system)
System Design and Development
System design translates the approved problem statement and objectives into a concrete technical blueprint—modules, data schemas, interfaces, and hardware wiring—before heavy coding or assembly begins. Development is the iterative construction of those modules into an integrated working prototype. Depending on the topic, a minor project takes one of three forms: a pure software system, a hardware system, or a hybrid system combining physical electronics with software.
| System Type | Core Components | Essential Design Artefacts | Common Development Pitfall |
|---|---|---|---|
| Software | Frontend UI, backend/API, algorithms or ML models, database | System architecture diagram, use-case diagram, ER schema, API contract, UI wireframes | Building UI and backend separately without testing the API contract early |
| Hardware | Sensors, actuators, microcontroller/FPGA, power supply, PCB or breadboard | Block diagram, circuit schematic, pinout table, power budget, enclosure sketch | Loose breadboard wiring, wrong voltage levels (3.3 V vs 5 V), burnt components |
| Hybrid | Embedded node (sensors + MCU) plus cloud/local server, database, and app | Hardware schematic, telemetry packet format, backend architecture, dashboard wireframe | Hardware delivery delays stalling the software team; fix by writing a sensor data simulator |
3.1.1 Essential design practices before coding
- Separate responsibilities cleanly: Divide the system into distinct layers—presentation (UI), application logic/algorithms, data storage, and (if hybrid) hardware abstraction—so one change does not break everything.
- Draw diagrams that match the real system: Examiners check whether your block diagram, DFD/sequence diagram, and ER diagram actually match your implemented code and tables. Keep diagrams updated whenever the design evolves.
- Build a thin end-to-end slice first: Instead of perfecting the login page in Week 4 and leaving core logic for Week 10, connect one input, one core processing path, and one output end-to-end early (a "walking skeleton"), then expand feature by feature.
+------------------+ GPIO/ADC +--------------------+
| Current & Temp | ---------------> | ESP32 Node |
| Sensors | | (Read & Filter) |
+------------------+ +--------------------+
|
Wi-Fi / HTTP JSON
v
+------------------+ SQLite +--------------------+
| Web Dashboard | <--------------- | Python FastAPI |
| (Charts & Alerts)| REST API | Backend Server |
+------------------+ +--------------------+Designing a hybrid QR-and-RFID smart library check-in system
A group plans a hybrid minor project: a smart library kiosk where students scan their RFID card and a book's QR/barcode to borrow or return books automatically, with a web portal for the librarian. Outline the system design artefacts and incremental development order.
Define the hardware and software boundaries:
- Hardware unit: ESP32 or Raspberry Pi connected to an RC522 RFID reader, a USB/serial barcode scanner, a 16x2 LCD (or small OLED) for instant status, and a buzzer for confirmation.
- Software unit: A local backend API, relational database (storing Students, Books, and Loans tables), and a librarian web dashboard.
Produce the core design artefacts:
- Draw a hardware wiring/pinout table (SPI pins for RC522, I2C pins for OLED).
- Design the ER diagram with three primary entities:
Student(id, card_uid, name),Book(isbn, copy_id, title, status), andLoan(loan_id, student_id, copy_id, issued_at, due_at, returned_at). - Specify the API contract:
POST /api/checkouttaking{card_uid, copy_id}and returning{ok, due_date, message}.
Sequence the development incrementally:
- Create the database and
/api/checkout+/api/returnendpoints; test with sample JSON requests. - Interface the RFID reader and display in standalone test scripts.
- Connect the microcontroller to the API over Wi-Fi, then build the librarian overdue-report dashboard.
The design separates the embedded kiosk hardware from the backend API and database using a clear ER schema, pinout table, and REST contract, and sequences development from backend + standalone sensor tests to full integration.
3.2 Application of programming skills, algorithms and engineering tools
Moving from classroom assignments to a semester project requires writing code that teammates can read, modify, and run reliably on demo day.
3.2.1 Applying programming skills and algorithms
- Modular code and clean interfaces: Group related functions into modules or classes with clear inputs and return values. Avoid writing a single 800-line script where database queries, UI rendering, and ML inference are tangled together.
- Defensive programming and error handling: Validate user inputs and sensor readings (for example, handle
NaNfrom a disconnected DHT22 sensor, empty form fields, or network timeouts) with clear log messages rather than letting the program crash silently. - Choosing the right algorithm: Match algorithmic complexity and model size to real project constraints:
- Use database indexes or hash maps instead of nested loops over thousands of records.
- Apply graph algorithms (BFS/Dijkstra) for routing, scheduling, or network path problems.
- Apply signal smoothing (moving average or median filter) to noisy ADC/sensor values before triggering thresholds.
- For AI/ML projects, establish a simple baseline (such as logistic regression or TF-IDF) before tuning complex neural networks so you can prove the extra complexity actually helps.
- Never hardcode secrets or machine paths: Store API keys, database URLs, and Wi-Fi credentials in environment variables or a local config file excluded from Git, and use relative paths so the code runs on any teammate's computer.
3.2.2 Engineering tools in daily workflow
| Tool Category | Practical Examples | How It Helps Your Project |
|---|---|---|
| Version Control | Git, GitHub, GitLab | Tracks every change, prevents overwriting teammates' work, enables safe feature branches |
| Environment & Packages | Python venv, pip, npm, PlatformIO | Locks library versions (requirements.txt / package.json) so the app builds on demo machines |
| API & DB Inspection | curl, Postman, Thunder Client, DB Browser for SQLite | Verifies backend endpoints and inspects database rows independently of the frontend |
| Code Quality | IDE debugger, linters (flake8, eslint), formatters | Catches syntax bugs, unused imports, and formatting drift before merging |
| Hardware Debugging | Serial Monitor, Digital Multimeter, Logic Analyser | Verifies supply voltages, baud rates, and sensor signals before blaming firmware logic |
3.3 Integration of concepts from different subjects
A minor project is rarely about a single course. Its strength—and what Institute of Engineering examiners specifically look for—is how you integrate concepts from multiple computer engineering subjects into one coherent system.
| Subject | Core Concepts Applied | Concrete Minor-Project Example |
|---|---|---|
| Computer Programming | Control flow, functions, file I/O, pointers, memory safety | Writing reliable C firmware to parse serial GPS frames or clean CSV logs |
| Object-Oriented Programming (OOP) | Classes, encapsulation, inheritance, interfaces, design patterns | Structuring a desktop/web backend with User, SensorNode, and AlertService classes |
| Software Engineering | SDLC models, requirement analysis, UML diagrams, version control, testing | Drafting SRS-style scope, UML sequence diagrams, Git workflow, and test cases |
| Artificial Intelligence (AI) | Search algorithms, heuristics, supervised/unsupervised ML, evaluation metrics | Classifying plant leaf diseases, predicting power load, or A* path planning |
| Compiler Design | Lexical analysis, regular expressions, tokenisation, parsing, ASTs | Building a custom query/rule parser, syntax checker, or domain-specific config validator |
| Big Data Technology | Data pipelines, stream/batch processing, distributed storage, aggregation | Ingesting high-frequency sensor or log streams and computing windowed summaries |
| Database Management System (DBMS) | ER modelling, normalisation (1NF-3NF), SQL queries, indexing, transactions | Designing normalised tables for an inventory/hospital portal with atomic billing transactions |
| Computer Organization & Architecture (COA) | Memory hierarchy, interrupts, timers, ADC/registers, execution latency | Using hardware timer interrupts and low-power sleep modes on a microcontroller |
| Computer Network | TCP/IP, HTTP/REST, MQTT, sockets, DNS, TLS security, latency | Transmitting encrypted JSON telemetry from an edge device to a cloud/LAN server |
| Electronic Devices | Diodes, transistors/MOSFET drivers, op-amps, voltage regulators, relays | Driving a 12 V DC pump safely via an optocoupler/MOSFET and flyback diode from 3.3 V GPIO |
Tracing multi-subject integration in a smart campus parking system
Explain how a minor project titled "Automated Campus Vehicle Entry and Parking Slot Monitor" integrates concepts from at least six different computer engineering subjects listed in the syllabus.
Hardware, electronics, and architecture layer:
- Electronic Devices: Ultrasonic/IR slot sensors, level shifters, and a relay/transistor driver circuit controlling a barrier gate motor with flyback diode protection.
- Computer Organization & Architecture: Configuring microcontroller GPIO interrupts, timers, and serial/SPI communication with minimal polling overhead.
Networking, data, and intelligence layer:
- Computer Network: Gate camera node sends compressed frames over LAN/HTTP to the campus server; slot nodes publish occupancy updates via MQTT.
- Artificial Intelligence: An OCR / number-plate recognition pipeline detects and reads license plates at the gate.
- Database Management System: Normalised relational tables record vehicles, entry/exit timestamps, and slot occupancy with indexed plate lookup.
Software design and parsing:
- OOP and Software Engineering: Clean service classes (
GateController,PlateRecognizer,ParkingRepository), UML diagrams, and Git feature branching. - Compiler Design (bonus integration): Regular-expression lexical rules validate Nepali/standard license-plate token patterns (province code, vehicle class, digits) to reject noisy OCR reads.
The parking project integrates Electronic Devices (sensor/relay circuits), COA (interrupts/timers), Computer Networks (HTTP/MQTT), AI (plate OCR), DBMS (normalised indexed logs), OOP/Software Engineering (modular classes and UML), and Compiler Design (regex token validation for plate strings).
3.4 Applications of project management skills such as work division, time management, leadership
Project Management in a Minor Project
Project management is the discipline of organising people, tasks, time, and risks so that a 3-4 member group delivers a tested working system and complete documentation within the semester deadline. Technical brilliance alone does not save a poorly coordinated team; clear work division, realistic time management, and steady leadership do.
3.4.1 Work division and ownership
Avoid two common traps: (1) letting one strong coder write everything while others only format slides (examiners spot this immediately during individual viva questioning), and (2) splitting work so rigidly that nobody understands anyone else's module.
| Module / Task | Primary Owner | Reviewer / Backup | Shared Responsibility |
|---|---|---|---|
| UI / Frontend / Mobile Screen | Member 1 | Member 2 | All review usability |
| Backend API & Database Schema | Member 2 | Member 3 | All agree API contract |
| Core Algorithm / ML / Firmware | Member 3 | Member 4 | All verify test accuracy |
| Testing, Deployment & Documentation | Member 4 | Member 1 | All write their module's report section & prepare for viva |
3.4.2 Time management and risk control
- Break work into 1-2 week milestones: Large vague tasks ("build backend") slip silently. Small concrete milestones ("user table + 3 CRUD endpoints passing curl tests by Friday") expose delays immediately.
- Time-box technical blockers: If a team member spends more than 2 days stuck on a library error or sensor driver, escalate to the whole group or supervisor instead of hiding the delay for two weeks.
- Hold short weekly stand-ups: Spend 15 minutes every week answering three questions: What did each member finish? What is next? What is blocking anyone? Keep brief meeting notes for supervisor reviews.
3.4.3 Leadership and conflict resolution
In a student group, leadership is not bossing teammates around; it is taking responsibility for coordination and unblocking progress:
- Keeping the shared task board (Trello, GitHub Projects, or a simple spreadsheet) and Gantt chart updated.
- Booking regular meetings with the supervisor and bringing concrete demos or questions.
- Resolving technical disagreements objectively—comparing options against scope, deadline, and a quick prototype rather than personal preference.
- Making sure quieter members get fair technical tasks and understand the integrated system before the final defence.
Re-balancing workload when one module falls behind schedule
In Week 7 of a 12-week project, an estimated 80 hours of integration and testing work remains across four members (originally 20 hours each). However, Member 3's ML training module still needs 32 hours of debugging and tuning, while Members 1, 2, and 4 have only 16 hours each left on their parts. How should the team lead manage the work division and schedule?
Check total remaining capacity: Originally planned: 20 + 20 + 20 + 20 = 80 hours. Revised estimate: 32 + 16 + 16 + 16 = 80 hours. The total team capacity is still sufficient if work is redistributed, whereas leaving Member 3 alone at 32 hours will delay integration by two weeks.
Reallocate tasks without breaking ownership:
- Move dataset labelling/cleaning and metric-plotting scripts (about 12 hours of Member 3's load) to Member 2 and Member 4, who finish their UI/API parts early.
- Have Member 1 prepare mock JSON predictions matching the agreed API schema so frontend integration proceeds in parallel without waiting for the final model weights.
Agree a checkpoint and inform the supervisor: Set a mid-week checkpoint (48-hour time-box) for the ML accuracy target. If accuracy still lags, switch to the simpler baseline model agreed in the proposal so the project remains on schedule for Week 9 testing.
Total remaining work is still 80 hours (32 + 16 + 16 + 16 = 80). The team lead keeps integration on time by using mock API responses, offloading dataset cleaning and evaluation scripts to members with spare capacity, and setting a 48-hour fallback checkpoint to a baseline model.
Practice Exercises: Design, Development and Project Management
What is the difference between a software, hardware, and hybrid minor project? Why should a hybrid project team build a software simulator for sensor data early in development?
Three project types: A software project delivers purely computer/mobile applications and algorithms; a hardware project centres on physical circuits, sensors, or embedded controllers; a hybrid project integrates physical hardware nodes with software services such as APIs, databases, and user dashboards.
Role of a sensor simulator: Hardware shipping, soldering errors, or faulty sensors often delay physical prototypes. A simulator emitting realistic dummy JSON/serial packets lets backend, database, and UI developers build and test the software pipeline immediately without sitting idle.
Software projects build pure applications, hardware projects build physical electronic/embedded devices, and hybrid projects combine both. A sensor simulator decouples software development from hardware delivery delays so integration and UI testing can start early.
Why is building a "walking skeleton" (thin end-to-end prototype) better than finishing the entire frontend first and the entire backend later? Explain with an example.
Risk of siloed development: If frontend and backend are built separately until late in the semester, mismatched field names, authentication bugs, and missing edge cases surface all at once during integration week.
Benefit of a walking skeleton: Connecting one minimal flow end-to-end early (for example, submitting one attendance form from the UI -> saving one row in SQLite via the API -> displaying it back) validates the architecture, setup, and data contract in Week 4 instead of Week 10.
A walking skeleton verifies the full pipeline (UI -> API -> database/hardware) early, exposing schema mismatches and environment issues when there is plenty of time to fix them, unlike siloed development that fails at last-minute integration.
Show how a minor project on an "IoT-Based Water Quality Monitoring and Alert Portal" integrates concepts from at least five computer engineering subjects.
Identify hardware and networking subjects:
- Electronic Devices: Interfacing pH/turbidity/TDS probes, signal conditioning, and voltage regulation.
- Computer Organization & Architecture: Microcontroller ADC sampling, timer interrupts, and low-power sleep scheduling.
- Computer Network: Sending telemetry packets reliably over Wi-Fi/HTTP or MQTT with retry logic.
Identify software, data, and intelligence subjects:
- Database Management System: Storing time-series readings and threshold rules in normalised tables with indexed timestamps.
- Software Engineering & OOP: Modular class design, UML diagrams, Git version control, and automated validation tests.
- Artificial Intelligence (optional extension): Anomaly detection or simple trend forecasting to warn of sudden contamination.
The project combines Electronic Devices (sensor interfacing), COA (ADC/timers/interrupts), Computer Networks (MQTT/HTTP telemetry), DBMS (normalised time-series storage), and Software Engineering/OOP (modular architecture, UML, Git, testing).
In a 4-member project group, Member A wrote 90% of the code while Members B, C, and D only wrote the report and made slides. What problems does this cause during evaluation, and how does proper work division prevent it?
Problems caused:
- High project risk: if Member A falls ill or misses a deadline, nobody else can debug or extend the code.
- Viva failure: Institute of Engineering examiners ask individual members to explain code modules and live changes; non-coding members cannot defend work they did not understand.
- Lower quality: one person lacks time for proper testing and refactoring.
Prevention via balanced ownership: Assign each member a distinct technical module as primary owner plus a secondary module to review, enforce weekly Git commits from all members, and hold brief code walk-throughs so everyone understands the full architecture.
Unequal coding creates a single point of failure, poor test coverage, and failed individual viva defences. Assigning every member a technical module plus code-review backup and enforcing regular shared Git commits prevents this.
During Week 8, a 4-member team has 14 days left before the final code freeze, and each member can dedicate 14 hours in total across those two weeks (56 team hours total). Their remaining bug-fix and integration list totals 44 hours, leaving 12 hours. Explain what the team leader should do with those 12 hours and how time-boxing helps if a critical bug appears.
Allocate the 12-hour buffer wisely: Total available = 14 x 4 = 56 hours; remaining development/bug-fix = 44 hours; buffer = 56 - 44 = 12 hours. Do not fill those 12 hours with new "nice-to-have" features. Reserve them for integration surprises, fresh-machine deployment rehearsal, and finalising test evidence for the report.
Apply time-boxing to critical bugs: Give any stubborn bug a strict time-box (for example, 4 hours of paired debugging). If unresolved when the timer expires, trigger a pre-agreed fallback (such as simplifying the feature or switching to a tested library) so the demo still works on freeze day.
With 56 team hours available and 44 hours of planned work, the remaining 12 hours must be protected as a risk and rehearsal buffer rather than spent on new features. Time-boxing stubborn bugs (for example to 4 hours before falling back) prevents one defect from derailing the freeze deadline.