Literature Review and Proposal
Open in the Padhaiko app2.1 Basic literature review and background study, study of existing systems in case of product based project
Literature Review and Existing System Study
A literature review (or background study) is a structured survey of published papers, technical reports, standards, and past projects related to your topic. Its goal is to establish what is already known, which methods work well, and what gap remains for your project to address. For a product-based project, this stage also includes a study of existing systems: inspecting current software, hardware, or manual workflows to identify missing features, usability problems, cost barriers, or local context gaps.
2.1.1 Conducting a basic literature review
In a minor project, you do not need to read fifty papers. Reading 5 to 10 high-quality, recent sources carefully is enough to build a solid foundation. Follow a systematic workflow:
- Formulate search keywords: Combine your domain, method, and target context (for example,
"Nepali OCR" AND "convolutional neural network"or"ESP32 smart irrigation" AND "soil moisture"). - Search trusted databases: Use IEEE Xplore, ACM Digital Library, Google Scholar, arXiv, official hardware/framework documentation, and your department's archive of past minor project reports.
- Screen titles and abstracts first: Discard sources that solve a completely different problem or require hardware you cannot access.
- Read critically and extract notes: For each selected paper or system, record the problem solved, dataset or inputs used, methodology or architecture, evaluation metric, and stated limitations.
- Synthesise into themes and gaps: Group similar approaches together rather than listing summaries one after another, and end with a clear statement of the research or engineering gap your project will fill.
2.1.2 Studying existing systems for product-based projects
If your team is building an application, portal, or embedded device, reviewing commercial products, open-source repositories, and current manual workflows is even more useful than academic papers alone.
| Aspect | Research-Based Literature Review | Product-Based Existing System Study |
|---|---|---|
| Primary Sources | Peer-reviewed journals, conference papers (IEEE, ACM), preprints, theses | Commercial apps, open-source projects, local business workflows, user interviews |
| Focus of Analysis | Algorithms, mathematical models, datasets, accuracy, latency, ablation results | Features, user interface, pricing, offline capability, deployment platform, reliability |
| How Gaps Are Framed | Lower accuracy on noisy data, high compute cost, missing local-language support | Manual paperwork, expensive licences, no Nepali/local format, poor mobile usability |
| Output in Report | Comparative literature table and selection of baseline method | Feature-comparison matrix and list of required system improvements |
| Source or System | Approach or Core Features | Dataset or Platform | Strengths | Limitations / Gap |
|---|---|---|---|---|
| Paper A (2023) | Lightweight CNN classifier | 2,000 lab leaf images | 94% accuracy on clean backgrounds | Accuracy drops outdoors with shadows |
| Existing App B | Cloud-based crop advisory | Android + paid API | Clean interface and reminders | Requires continuous internet and fee |
| Manual Practice | Farmer calls local technician | Phone / in-person | High trust and local context | Slow response during peak season |
Structuring a gap analysis for a local transit tracker
A team wants to build a product-based minor project: an offline-capable public bus route and fare finder for Kathmandu Valley commuters. Show how the team should conduct and summarise its study of existing systems.
Identify existing solutions to examine: The team lists three current alternatives: (1) asking conductors or fellow passengers (manual workflow), (2) general navigation apps such as Google Maps, and (3) static PDF/image route lists shared on social media.
Evaluate each alternative against user needs:
- Manual inquiry is free and works offline, but fails for unfamiliar routes or new visitors.
- General map apps provide GPS routing, but lack complete local microbus/tempo route coverage, offline fare tables, and Nepali/English stop aliases.
- Static images work offline, but cannot search from origin to destination or compute transfer stops.
State the engineering gap clearly:
None of the existing options combine offline shortest-path route lookup, fare estimation, and bilingual stop search in one lightweight mobile app. That verified gap justifies building the proposed system.
The team compares manual inquiry, general map apps, and static route charts in a feature matrix, highlights specific gaps (missing local microbus routes, no offline search, no fare lookup), and defines the project's niche as an offline-first bilingual route and fare finder.
2.2 Preparation of brief project proposal including objective and methodology
Project Proposal
A project proposal is a concise formal document submitted to the department and supervisor before full-scale development begins. It explains what problem the team is solving, why it matters, what exact objectives will be achieved, how the system will be designed and tested (methodology), and when each milestone will be completed.
2.2.1 Standard sections of a brief minor project proposal
A minor project proposal is typically 5 to 10 pages long. Departments may supply a template, so always check official formatting rules, but almost every Institute of Engineering proposal contains these core sections:
| Section | What to Write | Typical Length |
|---|---|---|
| Title Page | Concise project title, course code (ENCT 354), group members, roll numbers, supervisor, department | 1 page |
| Introduction and Background | Context of the domain, motivation, and brief summary of the problem | 0.5-1 page |
| Problem Statement | Clear statement of the specific issue, affected users, and limitations of current practice | 1-2 paragraphs |
| Objectives | One general objective plus 3-4 measurable, achievable specific objectives | 0.5 page |
| Scope and Limitations | Explicit in-scope deliverables and out-of-scope boundaries | 0.5 page |
| Literature Review / Existing Systems | Brief synthesis of 5-8 papers or products and the identified gap | 1-2 pages |
| Methodology | System architecture/block diagram, data flow, algorithms, testing and evaluation plan | 1.5-2 pages |
| Tools, Resources, and Budget | Hardware components, software stack, datasets, and estimated cost | 0.5 page |
| Work Plan (Gantt Chart) | Week-by-week schedule of tasks and member responsibilities | 0.5-1 page |
| Expected Outcomes and References | Concrete deliverables (working prototype, report, metrics) and properly formatted references | 0.5-1 page |
2.2.2 Writing clear objectives and methodology
- General objective: One overarching sentence describing the final system or study (for example, "To design and implement a low-cost IoT-based indoor air quality monitoring and alert system").
- Specific objectives: Break the general objective into 3 or 4 concrete, testable milestones using action verbs such as collect, design, implement, integrate, evaluate, compare. Every specific objective should map directly to a feature or experiment you can demonstrate during the final defence.
- Methodology: Explain how you will build and validate the system from input to output. Include:
- System block diagram or workflow: Show inputs, processing modules, storage, and outputs.
- Data or hardware acquisition: Describe what dataset you will use (public benchmark or self-collected) or which sensors/circuits you will interface.
- Core logic or algorithm: Name the specific algorithm, model, or software architecture (for example, Dijkstra's algorithm for shortest route, REST API + SQLite, or YOLOv8n fine-tuned on custom images).
- Verification and validation plan: State how you will measure success (unit tests, accuracy/F1-score, response latency, or user acceptance testing).
2.2.3 Planning the timeline with a Gantt chart
A Gantt chart maps tasks against weeks so the supervisor and evaluation committee can verify that the 1-credit project fits comfortably inside a single semester (typically 12 to 14 active weeks). Keep overlapping tasks realistic: literature study and tool setup finish early, implementation spans the middle weeks, and testing plus report writing never get squeezed into the final three days.
Task / Phase | W1-W2 | W3-W4 | W5-W6 | W7-W8 | W9-W10 | W11-W12
--------------------------------+-------+-------+-------+-------+--------+--------
1. Topic & Proposal Approval | [###] | | | | |
2. Literature & System Design | | [###] | | | |
3. Core Module Development | | | [###] | [###] | |
4. Integration & Mid-Term Demo | | | | [###] | |
5. Testing & Performance Tuning | | | | | [###] |
6. Final Report & Defence Prep | | | | | | [###]Drafting objectives and methodology for an exam-ready proposal
A group proposes an automated attendance system using classroom camera snapshots for a 40-student lab. Write the general objective, three specific objectives, and a concise four-stage methodology suitable for a project proposal.
Draft the general and specific objectives:
- General objective: To develop an automated classroom attendance system using face detection and recognition to reduce manual roll-call time.
- Specific objectives:
- Build a curated face dataset of 40 enrolled students (5 images per student under normal classroom lighting) and store embeddings securely in a local database.
- Implement a detection-and-recognition pipeline capable of identifying multiple faces in a single snapshot with at least 90% accuracy.
- Provide a web dashboard for lecturers to review, manually override, and export attendance records to CSV.
Structure the methodology pipeline:
- Data preparation: Capture and label 5 frontal/angled photos per student; align and resize faces during preprocessing.
- Model pipeline: Detect faces using a lightweight detector, extract fixed-length face embeddings, and match each embedding against stored student vectors using cosine similarity with a tuned rejection threshold to avoid false positives.
- Application layer: Wrap the inference engine in a Python backend API connected to an SQLite database and a simple lecturer review interface.
- Evaluation: Measure precision, recall, and processing time per snapshot across 10 test lab sessions, and verify CSV export integrity.
The proposal defines one clear general objective, three measurable specific objectives (dataset, 90% recognition target, lecturer dashboard), and a four-stage methodology (data preparation, detection/embedding pipeline, web/database layer, and quantitative evaluation).
2.3 Selection of software tools, technologies, and resources (Programming languages, frameworks, databases)
Selecting tools for a minor project is an engineering trade-off, not a popularity contest. Because a minor project lasts only one semester and carries 1 credit, picking an unfamiliar, overly complex stack often stalls the team during setup instead of letting them solve the core problem.
2.3.1 Programming languages, frameworks, and databases
| Category | Common Options | Best Suited For | Watch-Out in a Minor Project |
|---|---|---|---|
| Languages | Python, JavaScript/TypeScript, C/C++, Java/Kotlin, Dart | Python for AI/ML and quick backends; JS/TS for web; C/C++ for embedded firmware; Dart/Kotlin for mobile | Mixing too many languages increases integration bugs and learning overhead |
| Web & API Frameworks | FastAPI, Flask, Django, Express.js, React, Next.js | REST APIs, admin dashboards, full-stack web products | Heavy boilerplate or complex build tooling slows small teams; keep frontend simple if logic is backend-heavy |
| Mobile Frameworks | Flutter, React Native, native Android (Kotlin/Java) | Cross-platform or Android utility apps, field-data collection | Emulator/SDK setup consumes large RAM and disk space; test on real phones early |
| AI / CV / Data Libraries | scikit-learn, PyTorch, TensorFlow, OpenCV, Pandas | Classification, prediction, image processing, NLP tasks | Training deep models from scratch is slow; prefer pre-trained weights or transfer learning |
| Embedded / IoT Tools | Arduino IDE, PlatformIO, ESP-IDF, MQTT, Raspberry Pi OS | Sensor acquisition, microcontroller actuation, edge gateways | Hardware procurement delays and loose wiring; keep a software simulator or mock data ready |
| Databases | SQLite, PostgreSQL, MySQL, MongoDB, Firebase | SQLite for local/single-node apps; PostgreSQL/MySQL for relational multi-user data; MongoDB for flexible JSON | Avoid distributed clusters or paid cloud tiers that expire mid-semester |
2.3.2 Supporting engineering resources
Beyond languages and databases, every minor project depends on three supporting resources:
- Version control and collaboration: Use Git (GitHub or GitLab) with clear branch rules and a shared
.gitignoreso code is never lost on a single laptop. - Compute and hardware resources: Decide early whether model training needs Google Colab/Kaggle GPUs, whether sensors/boards (ESP32, Arduino, Raspberry Pi, cameras) are available in the college lab or must be bought, and ensure power and voltage levels match.
- Datasets and testing assets: Verify licensing and format of public datasets (Kaggle, UCI, Hugging Face, OpenStreetMap) or obtain permission if collecting local photos, surveys, or business records.
Justifying a technology stack for a hybrid IoT and web project
A 3-member group is building a smart greenhouse monitor that reads temperature, humidity, and soil moisture every 30 seconds, triggers a water pump automatically when soil is dry, and displays live readings and history on a web dashboard. Select and justify the programming languages, frameworks, database, and communication protocol.
Select embedded firmware and hardware interface: Use C/C++ (Arduino framework or PlatformIO) on an ESP32 microcontroller. The ESP32 includes built-in Wi-Fi, multiple ADC/GPIO pins for moisture and DHT22 sensors, and strong library support, avoiding an external Wi-Fi shield.
Select communication protocol and backend:
Use HTTP REST (JSON) or MQTT to send readings from the ESP32 to a Python (FastAPI or Flask) backend. Two team members already know Python, and FastAPI provides automatic request validation and fast setup.
Select database and frontend: Store time-stamped sensor readings and threshold settings in SQLite (or PostgreSQL if deployed on a shared lab server) because sensor logs are structured tabular records and SQLite requires zero separate server setup. Build the dashboard with lightweight HTML/CSS/JavaScript (or React if the team knows it) plus a simple charting library to plot trends.
The team selects C/C++ on ESP32 for hardware sensing/actuation, HTTP/MQTT for telemetry, Python (FastAPI/Flask) for the backend API, SQLite for zero-config structured storage, and HTML/JS for the dashboard—each justified by team familiarity, hardware fit, and low setup overhead.
Practice Exercises: Literature Review and Proposal
During your project defence, an examiner asks: "How is a literature review for a research-based minor project different from studying existing systems for a product-based project?" Give a clear viva answer.
Research-based literature review: Focuses on peer-reviewed papers, theses, and technical reports to compare algorithms, datasets, evaluation metrics, and theoretical limitations, leading to a technical method or experiment.
Product-based existing system study: Focuses on commercial apps, open-source tools, and manual local workflows to evaluate features, cost, platform support, usability, and offline readiness, leading to a software or hardware product specification.
A research-based literature review analyses published papers, models, datasets, and metrics to find a methodological gap, whereas a product-based existing system study inspects current applications and manual workflows to find missing features, usability issues, or local-context gaps.
What is a literature comparison matrix, and why is it better than writing separate paragraph summaries for ten papers in Chapter 2 of your proposal or report?
Definition: A literature comparison matrix is a structured table that compares multiple papers or systems side by side across consistent columns such as author/year, method, dataset, strengths, and limitations.
Why it is better: Separate paragraph summaries force the reader to compare methods mentally. A matrix synthesises the survey, makes trends and trade-offs visible at a glance, and clearly exposes the gap that justifies the proposed project.
A literature comparison matrix aligns reviewed papers or systems across common criteria (method, dataset, strengths, limitations) in one table, allowing readers to spot trade-offs and the remaining engineering gap immediately instead of wading through disconnected summaries.
List the essential sections of a brief minor project proposal and explain what the methodology section must contain so the supervisor approves it without major revisions.
Essential proposal sections: Title page, introduction/background, problem statement, general and specific objectives, scope and limitations, brief literature/system review, methodology, tools and resources, timeline (Gantt chart), expected outcomes, and references.
Contents of a strong methodology: A system block diagram or workflow, data collection or hardware setup plan, the specific algorithms or architectural pattern to be implemented, and an explicit testing and evaluation plan showing how each objective will be verified.
A brief proposal includes title, background, problem statement, objectives, scope, literature review, methodology, tools/resources, Gantt chart, expected outcomes, and references. Its methodology must clearly show the system block diagram, input/data source, core processing algorithm or architecture, and how results will be tested.
A group has 12 weeks to complete a minor project and plans five sequential/overlapping phases: Proposal and Approval (Weeks 1-2), Design and Tool Setup (Weeks 3-4), Implementation (Weeks 5-8), Testing and Tuning (Weeks 9-10), and Report and Defence (Weeks 11-12). Check whether the durations cover the 12-week semester and explain why reserving Weeks 9-12 for testing and documentation is critical.
Check total planned duration: 2 + 2 + 4 + 2 + 2 = 12 weeks, which matches the 12-week semester exactly with dedicated blocks for each stage.
Why Weeks 9-12 matter: Leaving testing and documentation until the final week causes undetected integration bugs, missing performance measurements, and rushed reports. Reserving two full weeks for testing and two weeks for report writing and defence rehearsal gives time to fix defects and polish demonstrations.
The five phases sum to 12 weeks (2 + 2 + 4 + 2 + 2 = 12). Reserving Weeks 9-12 explicitly protects time for bug fixing, validation metrics, report formatting, and presentation rehearsal rather than cramming them into the final days.
An examiner asks: "Why did your group choose SQLite instead of MongoDB (or PostgreSQL) for your minor project?" How should you justify a database and programming stack choice in a viva?
Compare data model and project scale: Explain the shape of the data (structured relational records vs. nested unstructured documents) and the expected concurrency (single-node desktop/mobile app vs. multi-user web server).
Relate to FITS criteria (Familiarity, Integration, Time/Cost, Support): Justify SQLite by noting zero separate server administration, ACID transactions, native Python/Android support, and offline portability; or justify PostgreSQL/MongoDB only when multi-user concurrency, complex queries, or schema-free documents genuinely require it.
Justify the choice using data structure, concurrency needs, and team constraints: for a single-node or offline minor project with structured tables, SQLite provides zero-configuration ACID reliability and easy deployment without over-engineering a heavy database server.