Initial Project Development Phase
Open in the Padhaiko app6.1 Data collection or experimental/product set up
Once the department approves the Week-3 Proposal, the project enters Initial Project Development (Weeks 4–12). The first practical step is establishing the empirical or engineering foundation—either collecting and preparing real data / experimental testbeds (Research Track) or setting up the product development environment, hardware testbench, and sample data (Product and Internship Tracks).
Data Collection and Experimental/Product Setup
Data collection and experimental/product setup is the pre-implementation engineering phase in which a group acquires, cleans, labels, and partitions datasets (or builds reproducible hardware/software environments, repositories, and staging testbeds) so that design, algorithm development, and Proof-of-Concept validation rest on verifiable inputs rather than ad-hoc placeholders.
| Track | Data & Input Preparation | Environment & Tooling Setup | Verification Before Moving to 6.2 |
|---|---|---|---|
| Research Track | Curate public or field-collected datasets; define annotation guidelines; split train / validation / test cleanly with zero leakage | Reproducible virtual env/Docker, fixed random seeds, experiment tracker (CSV/MLflow/W&B), baseline evaluation script | Dataset statistics (class counts, missing values, split sizes) documented; baseline script runs end-to-end |
| Product Track | Gather real user workflows/field samples; create realistic seed datasets and edge-case test fixtures | Shared Git repo with branching rules, linter/formatter, local DB migrations, Docker Compose or hardware breadboard testbench | Fresh clone boots locally in under 5 minutes; hardware sensors read valid baseline values |
| Internship Track | Obtain mentor-approved anonymized or synthetic sample dumps conforming to NDA boundaries | Local mirror or sandbox matching host staging environment without touching production customer DBs | Sample data schema matches production contract; mentor confirms sandbox safety |
6.2 Analysis and design
Before writing production application code or complex training loops, translate your proposal methodology into precise engineering specifications and visual architecture designs. Examiners inspect Chapter 6.2 artifacts closely during the final Project I presentation to verify that the system was engineered rather than cobbled together.
System Analysis and Design
Analysis and design converts user requirements, research constraints, or host system interfaces into unambiguous structural and behavioral blueprints—covering functional and non-functional requirements, system architecture, data flow / sequence diagrams, database schemas or hardware wiring schematics, and interface contracts.
6.2.1 Core Artifacts Expected by Track
Do not draw every UML diagram blindly just to pad pages. Pick the 3 to 5 diagrams that genuinely clarify your system:
| Diagram / Spec | Best Used For | Key Information It Must Convey |
|---|---|---|
| System Block / Layered Architecture | Every project (all 3 tracks) | Major subsystems, boundaries (client, API, ML worker, DB, sensors), and communication protocols |
| Data Pipeline / Model Architecture Diagram | Research & AI/ML projects | Raw input dimensions -> preprocessing steps -> model layers/modules -> loss/post-processing -> output format |
| Use Case & Sequence Diagrams | Product & interactive systems | Actor permissions (RBAC), request-response lifecycle, error/offline fallback flows |
| ER Diagram / Schema + API Contract | Web, mobile, big-data apps | Tables/collections, primary & foreign keys, indexes, and REST/GraphQL endpoint payloads |
| Circuit Schematic & Timing / Pinout Table | Embedded Systems & IoT | Microcontroller pins, voltage levels (3.3V vs. 5V), communication buses (I2C/SPI/UART), power budget |
6.3 Methodology development
With data/testbeds ready and architecture designed, methodology development builds the core intellectual engine of the project—the algorithms, mathematical models, protocol handlers, or system workflows that solve the problem identified in Chapter 2.
Methodology Development
Methodology development is the iterative construction and refinement of the core computational pipeline—progressing systematically from a simple, working baseline through modular improvements, ablation checks, or architectural refinements tied directly to the project's objectives.
6.3.1 Iterative Baseline-First Strategy
The most reliable engineering discipline in Project I is Baseline First, Complexity Second:
- Build the simplest end-to-end baseline: For ML, train logistic regression or a lightweight pretrained backbone first; for software, connect one thin vertical slice from UI -> API -> DB; for IoT, read one sensor and log locally.
- Verify evaluation harness early: Confirm your metrics script, latency logger, or unit tests work on the baseline before tuning anything.
- Iterate on one variable at a time: Change one preprocessing step, model block, caching layer, or scheduling policy per experiment and log the delta.
- Document failed attempts too: Knowing why a technique did not work (with logged numbers) strengthens your Project I progress report and viva defence.
Developing a Baseline-to-Improved Methodology for Nepali Document OCR
A Research Track group is developing a Mobile Scanner OCR Pipeline for Degraded Nepali Municipal Notices. Outline how they should execute Sections 6.1, 6.2, and 6.3 systematically during Project I rather than jumping straight into training a giant neural network.
6.1 Data Collection and Partitioning: The group collects 300 scanned/photographed notices from public municipal boards (skewed, stamped, folded), crops text lines, and defines strict annotation guidelines for Devanagari matras and conjuncts. They split by document page (200 train, 50 validation, 50 held-out test) so lines from the same notice never appear in both training and testing.
6.2 Pipeline and Design Specification: They design a clean 4-stage pipeline diagram: Camera Input -> Perspective & Illumination Correction -> Line Segmentation -> Sequence Recognition -> Unicode Normalization & Spell/Dictionary Post-Check, specifying exact tensor/image contracts between stages.
6.3 Baseline-First Methodology Development:
- Iteration 1 (Baseline): Run off-the-shelf Tesseract Nepali + basic Otsu thresholding on the 50 validation pages; record Character Error Rate (CER) and Word Error Rate (WER) to establish a clear benchmark.
- Iteration 2 (Preprocessing Upgrade): Replace global Otsu thresholding with adaptive CLAHE + Sauvola binarization and deskewing; log CER reduction on folded/shadowed notices.
- Iteration 3 (Core Model Improvement): Fine-tune a lightweight CRNN/TrOCR model on synthetic + real cropped lines and compare CER/WER and per-page inference time directly against Iteration 1 and 2.
By splitting data at the document level (6.1), specifying stage-by-stage input/output contracts (6.2), and progressing from a Tesseract baseline through adaptive preprocessing to a fine-tuned recognizer with logged CER/WER deltas (6.3), the team builds defensible, reproducible engineering progress.
6.4 Application of programming skills, algorithms and engineering tools
Section 6.4 emphasizes software and engineering craftsmanship: turning designs into clean, maintainable, version-controlled code using appropriate algorithms, data structures, and industry-standard engineering tools.
Engineering Craftsmanship and Tooling
Application of programming skills, algorithms, and engineering tools refers to writing modular, testable, documented code and leveraging modern engineering tooling—version control (Git), automated testing, dependency pinning, containerization, debugging/profiling, and issue tracking—to ensure reliability and smooth collaboration across the team.
| Engineering Practice | Concrete Tooling Example | Why Examiners & Teammates Value It |
|---|---|---|
| Version Control Discipline | Git feature branches, Pull Requests, .gitignore excluding weights/secrets, meaningful commit messages | Proves individual member commits and prevents overwritten code |
| Modular Architecture | Separate data/, models/ or services/, api/, tests/, configs/ directories | Enables parallel work and clean unit testing |
| Reproducible Environments | requirements.txt / pyproject.toml, package-lock.json, Dockerfile | Prevents "works on my laptop" failures during viva demo |
| Automated Verification | pytest, jest, API integration tests, hardware serial loopback checks | Catches regressions before Proof-of-Concept demo |
| Algorithmic Efficiency | Choosing appropriate data structures (KD-trees, priority queues, hash indexes, quantized inference) | Shows B.E.-level computer engineering judgment over brute-force code |
major-project-repo/
|-- README.md # Setup, architecture overview, run commands
|-- docs/ # Concept note, proposal, diagrams, meeting logs
|-- configs/ # YAML/JSON hyperparameters, env templates (.env.example)
|-- data/ # Sample fixtures & download/preprocess scripts (never commit GBs)
|-- src/
| |-- core/ # Core algorithms, ML pipeline, or embedded firmware
| |-- api/ # REST/gRPC handlers, auth, validation schemas
| |-- ui/ # Web or mobile client source
|-- tests/ # Unit, integration, and benchmark evaluation scripts
|-- scripts/ # Reproducible training, seeding, and PoC demo runners6.5 Proof of concept and preliminary works
By Weeks 10–12 (just before submitting the Project I Progress Report two weeks prior to semester end), the group must integrate its work into a tangible Proof of Concept (PoC) and compile preliminary results.
Proof of Concept (PoC) and Preliminary Works
A Proof of Concept (PoC) is a working, end-to-end minimal demonstration proving that the project's core technical hypothesis or architecture actually functions on real inputs—even if secondary UI features, full-scale deployment, or extended edge-case optimizations are deferred to Project II. Preliminary works include initial benchmark numbers, prototype screenshots/videos, hardware test logs, and identified bottlenecks guiding Phase II.
6.5.1 What Counts as a Strong PoC vs. an Insufficient PoC
| Aspect | Strong Project I Proof of Concept | Weak / Unacceptable PoC |
|---|---|---|
| System Flow | End-to-end vertical slice works on real or realistic test inputs (input -> core logic/model -> verified output) | Only static HTML/Figma login screens or disconnected tutorial scripts |
| Evidence & Metrics | Preliminary benchmark table (e.g., baseline vs. initial model accuracy, latency, memory usage, or sensor packet loss) | Purely qualitative claims ("our app works smoothly") with zero measured results |
| Honesty on Limitations | Documents concrete failure cases discovered so far and exact Project II roadmap to fix them | Pretends prototype is 100% finished with hardcoded mock responses |
Scoping a Verifiable Proof of Concept for a Smart-Grid IoT Fault Monitor
A 3-member Product Track team is building an IoT Distribution Transformer Health & Overcurrent Alert System using current/temperature sensors, an ESP32 node, MQTT, a backend server, and a mobile alert dashboard. Define what constitutes a solid Project I Proof of Concept and Preliminary Works by Week 12.
Define the vertical end-to-end PoC slice: Instead of waiting until all 10 dashboard charts and SMS billing rules are coded, the team focuses on one complete, live hardware-to-cloud-to-UI loop:
- One physical ESP32 prototype reading a calibrated ACS712/CT current sensor + DS18B20 temperature sensor every 2 seconds on a controlled bench load.
- MQTT over TLS publishing telemetry packets to a containerized Mosquitto broker -> FastAPI/TimescaleDB backend.
- Rule-based threshold + moving-average spike detector flagging simulated overcurrent/overheat events on a basic live web status page.
Collect preliminary engineering measurements (Preliminary Works):
- Calibration check: Compare ESP32 sensor current readings against a laboratory clamp multimeter across 5 load steps; report mean absolute error.
- Reliability test: Run a 6-hour continuous test and record MQTT packet delivery success rate, average end-to-end alert latency (sensor spike -> browser alert), and local ring-buffer behavior during a 10-minute Wi-Fi disconnect.
Document remaining Project II roadmap: Explicitly list what stays for Semester 8: weatherproof enclosure + solar/battery power backup, predictive ML anomaly trend scoring, multi-node LoRaWAN gateway fallback, and field pilot installation.
A single calibrated ESP32 node streaming live bench-load data over MQTT to a backend database and triggering real-time alerts—backed by calibration error tables, 6-hour reliability logs, and disconnect recovery tests—provides an indisputable Project I Proof of Concept.
Viva-Style Questions: Initial Development and Proof of Concept
What is a Proof of Concept (PoC) in Project I, and how does an examiner distinguish a genuine PoC from a UI mockup or hardcoded demo?
Definition of PoC: A PoC is a working, vertical end-to-end slice demonstrating that the project's core algorithm, hardware integration, or architectural workflow functions on genuine inputs.
How examiners verify authenticity: Examiners test live with unseen inputs (not just pre-saved screenshots), inspect logs/code/database entries generated during the run, check Git commit history, and ask for preliminary quantitative metrics (e.g., validation accuracy, response time, error rate) rather than hardcoded JSON responses.
A PoC proves core technical feasibility through a live end-to-end vertical slice on real inputs. Examiners distinguish it from mockups by testing unseen inputs live, inspecting generated database/model outputs, and reviewing preliminary quantitative metrics.
Explain "data leakage" in Section 6.1 and give one common example of how students accidentally introduce it during data preparation.
Meaning of data leakage: Data leakage occurs when information from the held-out test/evaluation split influences training or preprocessing, causing test metrics to appear unrealistically high compared to real-world deployment.
Common student mistake:
- Applying normalization (
StandardScaler), TF-IDF fitting, or SMOTE oversampling on the entire dataset before performingtrain_test_split. - Splitting augmented or overlapping frames (e.g., consecutive video frames from the same person or cropped lines from the same page) randomly across train and test sets instead of grouping by subject/session/document.
Data leakage happens when test-set characteristics leak into training—for example, running SMOTE oversampling or feature scaling before splitting, or letting frames from the same subject appear in both train and test splits—producing inflated metrics that fail in real testing.
Why does Section 6.3 recommend building a simple baseline first before implementing a complex neural network or distributed microservice architecture?
Engineering rationale for Baseline First:
- End-to-end validation: Confirms data loading, schema contracts, and evaluation scripts are bug-free early.
- Benchmark reference: Without a simple baseline (e.g., rule-based heuristic, logistic regression, or single-node REST API), you cannot prove that added model/system complexity actually improves performance.
- Schedule insurance: Guarantees you always have a working PoC before the Project I progress deadline even if advanced experiments need extra tuning in Project II.
A simple baseline validates the data and evaluation pipeline early, establishes a measurable reference point to justify later complexity, and protects the team's schedule so a working PoC is guaranteed by the progress report deadline.
Which design artifacts in Section 6.2 are essential for (a) an AI/ML Research Track project and (b) a Full-Stack Product Track project, and why shouldn't every project draw identical diagrams?
Tailoring diagrams to project nature:
- (a) AI/ML Research Track: Data acquisition & split diagram, preprocessing/augmentation flow, neural/algorithmic architecture diagram with tensor shapes, and experimental evaluation pipeline. (An ER diagram of a 1-table user login adds little value here.)
- (b) Full-Stack Product Track: System context & layered architecture, Use Case diagram, ER diagram / database schema, API sequence diagrams (including auth/offline fallback), and key wireframes.
Why tailor rather than template-stuff: Diagrams exist to communicate technical decisions and interface boundaries clearly; irrelevant diagrams waste report space and invite viva criticism.
Research projects need data-split, pipeline, and model architecture diagrams, whereas Product projects need system architecture, ER/schema, use-case, and sequence diagrams. Tailoring diagrams ensures every figure explains actual engineering structure rather than padding pages.
A group's Git repository shows 95 percent of commits were pushed by one student on the night before the Project I deadline, while the other two members have almost no commits. What problems does this create during evaluation, and what engineering workflow prevents it?
Evaluation and technical risks:
- Examiners frequently inspect commit history or ask module-specific questions; uneven commits signal poor teamwork, single-point-of-failure risk, or unverified contributions.
- Huge last-minute commits skip integration testing and break demos.
Preventive engineering workflow: Use feature branches per member (feat/data-pipeline, feat/api-auth, feat/ui-dashboard), require weekly small Pull Requests reviewed by teammates, include unit tests (pytest/jest) in CI or pre-demo checklists, and commit regularly from Week 4 onward.
Lopsided last-minute commits signal weak collaboration and fragile untested code. Using per-member feature branches, regular weekly commits, peer-reviewed Pull Requests, and automated tests ensures verifiable contributions and stable integration.