PadhaikoAll subjects

Initial Project Development Phase

Project I (ENCT 413)

Open in the Padhaiko app

6.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).

Definition

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-Specific Setup Checklist (Chapter 6.1)
TrackData & Input PreparationEnvironment & Tooling SetupVerification Before Moving to 6.2
Research TrackCurate public or field-collected datasets; define annotation guidelines; split train / validation / test cleanly with zero leakageReproducible virtual env/Docker, fixed random seeds, experiment tracker (CSV/MLflow/W&B), baseline evaluation scriptDataset statistics (class counts, missing values, split sizes) documented; baseline script runs end-to-end
Product TrackGather real user workflows/field samples; create realistic seed datasets and edge-case test fixturesShared Git repo with branching rules, linter/formatter, local DB migrations, Docker Compose or hardware breadboard testbenchFresh clone boots locally in under 5 minutes; hardware sensors read valid baseline values
Internship TrackObtain mentor-approved anonymized or synthetic sample dumps conforming to NDA boundariesLocal mirror or sandbox matching host staging environment without touching production customer DBsSample 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.

Definition

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:

High-Value Design Diagrams for Computer Engineering Projects
Diagram / SpecBest Used ForKey Information It Must Convey
System Block / Layered ArchitectureEvery project (all 3 tracks)Major subsystems, boundaries (client, API, ML worker, DB, sensors), and communication protocols
Data Pipeline / Model Architecture DiagramResearch & AI/ML projectsRaw input dimensions -> preprocessing steps -> model layers/modules -> loss/post-processing -> output format
Use Case & Sequence DiagramsProduct & interactive systemsActor permissions (RBAC), request-response lifecycle, error/offline fallback flows
ER Diagram / Schema + API ContractWeb, mobile, big-data appsTables/collections, primary & foreign keys, indexes, and REST/GraphQL endpoint payloads
Circuit Schematic & Timing / Pinout TableEmbedded Systems & IoTMicrocontroller 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.

Definition

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:

  1. 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.
  2. Verify evaluation harness early: Confirm your metrics script, latency logger, or unit tests work on the baseline before tuning anything.
  3. Iterate on one variable at a time: Change one preprocessing step, model block, caching layer, or scheduling policy per experiment and log the delta.
  4. Document failed attempts too: Knowing why a technique did not work (with logged numbers) strengthens your Project I progress report and viva defence.
Example 6.1

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.
Answer:

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.

Definition

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.

Essential Engineering Habits and Tools for Project I
Engineering PracticeConcrete Tooling ExampleWhy Examiners & Teammates Value It
Version Control DisciplineGit feature branches, Pull Requests, .gitignore excluding weights/secrets, meaningful commit messagesProves individual member commits and prevents overwritten code
Modular ArchitectureSeparate data/, models/ or services/, api/, tests/, configs/ directoriesEnables parallel work and clean unit testing
Reproducible Environmentsrequirements.txt / pyproject.toml, package-lock.json, DockerfilePrevents "works on my laptop" failures during viva demo
Automated Verificationpytest, jest, API integration tests, hardware serial loopback checksCatches regressions before Proof-of-Concept demo
Algorithmic EfficiencyChoosing appropriate data structures (KD-trees, priority queues, hash indexes, quantized inference)Shows B.E.-level computer engineering judgment over brute-force code
Recommended Repository Structure for a Major Project (Project I -> Project II)Text
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 runners

6.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.

Definition

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

AspectStrong Project I Proof of ConceptWeak / Unacceptable PoC
System FlowEnd-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 & MetricsPreliminary 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 LimitationsDocuments concrete failure cases discovered so far and exact Project II roadmap to fix themPretends prototype is 100% finished with hardcoded mock responses
Example 6.2

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.

Answer:

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

Question 1

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.

Answer:

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.

Question 2

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:

  1. Applying normalization (StandardScaler), TF-IDF fitting, or SMOTE oversampling on the entire dataset before performing train_test_split.
  2. 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.
Answer:

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.

Question 3

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:

  1. End-to-end validation: Confirms data loading, schema contracts, and evaluation scripts are bug-free early.
  2. 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.
  3. 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.
Answer:

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.

Question 4

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.

Answer:

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.

Question 5

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:

  1. Examiners frequently inspect commit history or ask module-specific questions; uneven commits signal poor teamwork, single-point-of-failure risk, or unverified contributions.
  2. 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.

Answer:

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.

← Proposal Report Submission and PresentationProgress Report Submission and Presentation →