# Help with Final Year Major Project

**URL:** <https://onehack.st/t/help-with-final-year-major-project/325450>\
**Category:** Discussion & Solutions\
**Tags:** help\
**Created:** [September 10, 2026, 1:26pm UTC](https://onehack.st/t/help-with-final-year-major-project/325450 "2026-09-10T13:26:26Z")\
**Posts on this page:** 3\
**Page:** 1

<div class="post-metadata">

**Author:** ![Stick\_Chick](https://onehack.st/user_avatar/onehack.st/stick_chick/32/154033_2.png) [@Stick\_Chick](https://onehack.st/u/Stick_Chick)\
**Post date:** [September 10, 2026, 1:26pm UTC](https://onehack.st/t/help-with-final-year-major-project/325450/1 "2026-09-10T13:26:26Z")

</div>

I needed help with my final year project since everything at this point is done by AI, professors have stopped appreciating Deep Learning projects aswell.

Is there any place or any projects that someone can send over?

---

<div class="post-metadata">

**Author:** ![WhiteHat](https://onehack.st/user_avatar/onehack.st/whitehat/32/162514_2.png) [@WhiteHat](https://onehack.st/u/WhiteHat)\
**Post date:** [September 19, 2026, 8:38pm UTC](https://onehack.st/t/help-with-final-year-major-project/325450/2 "2026-09-19T20:38:26Z")

</div>

### You do not need a new project — you need a new angle

① FIND an idea → ② MAKE it new → ③ BUILD it free → ④ WRITE it → ⑤ DEFEND it

Your professor has seen the same five projects. This reply shows where ideas live, how to twist an old one into something new, and how to build, write and defend it for free. No money, no lab, no permission needed.

**🔎 Where to find ideas**

| Place | What you get |
| --- | --- |
| build-your-own-x | build guides: database, OS, renderer |
| project-based-learning | full builds, sorted by language |
| Devpost · Devfolio · lablab.ai | hackathon projects, winners marked |
| [Hackaday.io](http://Hackaday.io) | open-hardware builds |
| awesome-public-datasets · awesome | dataset and list indexes |
| GitHub topic student-project | what classmates already shipped |
| University project galleries | real final-year titles |

🔗 **[github.com/codecrafters-io/build-your-own-x](https://github.com/codecrafters-io/build-your-own-x)**  
🔗 **[github.com/practical-tutorials/project-based-learning](https://github.com/practical-tutorials/project-based-learning)**  
🔗 **[devpost.com/software](https://devpost.com/software)**  
🔗 **[lablab.ai/apps](https://lablab.ai/apps)**  
🔗 **[hackaday.io/projects](https://hackaday.io/projects)**  
🔗 **[github.com/awesomedata/awesome-public-datasets](https://github.com/awesomedata/awesome-public-datasets)**

**🔧 How to make an old idea new**

1. **Swap the data** — same method, new corpus
2. **Move a method across fields** — NLP trick onto sensor data
3. **Add a constraint** — run it on a microcontroller
4. **Audit a model** — bias or robustness study
5. **Reproduce a result** — and report where it breaks
6. **Make the dataset** — the benchmark is the paper
7. **Add a human** — labelling becomes the research
8. **Go real-time** — streaming, on-device, offline
9. **Open the world** — unseen classes, unseen domains

**🗄 Data almost nobody uses**

| Source | Project it enables |
| --- | --- |
| NOAA space weather | storm predictor |
| CelesTrak orbits | satellite pass tracker |
| NASA FIRMS fires | wildfire alerts |
| Copernicus Sentinel | land change detector |
| Global Fishing Watch | dark-vessel detector |
| ICIJ Offshore Leaks | ownership graph |
| USGS + Raspberry Shake | earthquake detector |
| IODA + Cloudflare Radar + OONI | shutdown map |
| Lichess database | engine training |
| Cricsheet + StatsBomb + FastF1 | sports analytics |
| Zooniverse | citizen-science labels |

🔗 **[services.swpc.noaa.gov/json](https://services.swpc.noaa.gov/json/)**  
🔗 **[celestrak.org/NORAD/elements](https://celestrak.org/NORAD/elements/)**  
🔗 **[firms.modaps.eosdis.nasa.gov/api](https://firms.modaps.eosdis.nasa.gov/api/)**  
🔗 **[dataspace.copernicus.eu](https://dataspace.copernicus.eu/)**  
🔗 **[globalfishingwatch.org/our-apis](https://globalfishingwatch.org/our-apis/documentation/)**  
🔗 **[offshoreleaks.icij.org/pages/database](https://offshoreleaks.icij.org/pages/database)**  
🔗 **[earthquake.usgs.gov/earthquakes/feed/v1.0/geojson.php](https://earthquake.usgs.gov/earthquakes/feed/v1.0/geojson.php)**  
🔗 **[ioda.inetintel.cc.gatech.edu](https://ioda.inetintel.cc.gatech.edu/)**  
🔗 **[database.lichess.org](https://database.lichess.org/)**  
🔗 **[cricsheet.org/downloads](https://cricsheet.org/downloads/)**  
🔗 **[dataportals.org](https://dataportals.org/)**

**✅ Pick one in ten minutes**

- one way from the nine
- one data source that looks interesting
- two papers, read their future-work lines
- write your one-sentence claim
- start building

> **🛠 Build it free**
>
> - **GPU** : Kaggle 30 hours a week · Colab T4 · Lightning 80 hours · Modal 30 dollars a month
> - **Demo host** : Cloudflare Pages · Streamlit Cloud · Gradio share
> - **No hardware** : Wokwi · Tinkercad Circuits · EDA Playground · Gazebo · Sim2Bot
> - **CAD and sim** : KiCad · FreeCAD · OpenSCAD · Onshape free · Octave
> - **Scaffold** : cookiecutter-data-science · cookiecutter-modern-ml · Paper2Code
> - **Polish** : free .me domain · uptime page · one-click demo link

> **📄 Write and publish**
>
> - **Papers free** : Unpaywall · OpenAlex · Semantic Scholar · CORE · DOAJ
> - **Track the field** : Connected Papers · ResearchRabbit · Litmaps
> - **Templates** : Overleaf IEEE · ACM acmart · Springer lncs · Elsevier elsarticle
> - **Write** : Zotero · LanguageTool · Inkscape · [draw.io](http://draw.io)
> - **Publish free** : arXiv or Zenodo DOI · student journals · IEEE Student Paper Contest · ACM SRC
> - **Check a venue** : Think.Check.Submit
> - **Stay clean** : cite your own earlier work · add an AI-use line
> 
> The forum already covered the publishing path: 🔗 **[onehack.st/t/need-advice-fast-track-publishing-in-ieee-or-reputed-research-journals/323307](https://onehack.st/t/need-advice-fast-track-publishing-in-ieee-or-reputed-research-journals/323307)**

**🎤 Defend it**

> “I did not invent a new architecture — I moved a known method onto data from [source], where it had never been tested, and I report both where it holds and where it breaks.”

**🧠 Six words that make you sound like a researcher**

- **novelty** — a new result, setting or artefact
- **baseline** — what you must beat
- **ablation** — remove a piece, show its value
- **SOTA** — the best published number
- **preprint** — a public draft with a DOI
- **reproducibility** — someone can rerun you

 ![this is fine](https://onehack.st/uploads/default/original/3X/d/c/dcd2e4713e75ad7c3e27f7827f2f88cdb3efae47.gif)  

the room is on fire · the coffee is fine · the deadline is real

---

<div class="post-metadata">

**Author:** ![Indianapolis](https://onehack.st/user_avatar/onehack.st/indianapolis/32/150586_2.png) [@Indianapolis](https://onehack.st/u/Indianapolis)\
**Post date:** [October 3, 2026, 10:40am UTC](https://onehack.st/t/help-with-final-year-major-project/325450/3 "2026-10-03T10:40:15Z")

</div>

You probably do not need someone else’s finished project. You need a manageable baseline, a clear research question, and one small thing that makes your work different.

Your professor is probably tired of seeing:

```plaintext
Download a popular dataset→ train CNN/YOLO/LSTM→ report accuracy→ build a Streamlit interface

```

That does not mean deep-learning projects are useless. It means the project needs a stronger question than “can I train a model?”

## **The easiest way to make a project original**

Take an existing method and change one important variable:

- Use a different dataset or region
- Compare lightweight and large models
- Test performance with limited data
- Study bias or failure cases
- Make the model work offline
- Run it on low-end hardware
- Test it under noise or missing data
- Compare accuracy against speed and memory
- Reproduce an existing paper and explain where it fails
- Add human feedback or active learning
- Build a useful system around the model instead of only showing accuracy

A good final-year project can be:

> “I evaluated whether an existing method works reliably under a new constraint.”

It does not have to invent a brand-new neural-network architecture.

## **Project ideas that are realistic**

### **1. Wildfire detection with uncertainty**

Use satellite fire detections and weather data to classify areas as low, medium, or high risk.

Possible research question:

> Does adding weather and vegetation information improve wildfire-risk prediction compared with satellite data alone?

You can compare:

- Random Forest
- XGBoost
- CNN or LSTM
- A simple baseline model

Add a useful angle:

- Compare different regions
- Test seasonal performance
- Measure false alarms
- Show uncertainty instead of only a yes/no prediction
- Build a map dashboard

NASA FIRMS provides near-real-time active-fire data, although the near-real-time product is not considered science-quality, so your project should clearly describe its limitations

### **2. Lightweight plant-disease detection**

Instead of training a large image model, compare models designed for low-resource devices.

Research question:

> How much accuracy is lost when a plant-disease model is compressed for mobile or edge-device deployment?

Measure:

```plaintext
AccuracyModel sizeInference timeRAM usageEnergy or CPU usage

```

Compare:

- MobileNet
- EfficientNet-Lite
- Quantized versions
- A larger model as the baseline

This is stronger than simply saying “I trained a plant-disease classifier.”

### **3. Misinformation or claim classification**

Build a system that classifies claims as supported, contradicted, or unverifiable using a public fact-checking dataset.

The important part is not just the classifier. Study:

- Performance across topics
- Performance on short versus long claims
- Whether the model relies on keywords
- Explainability
- False confidence
- Performance when the claim is reworded

Do not present it as a system that decides absolute truth. Present it as a research prototype that assists fact-checking.

### **4. Traffic or air-quality forecasting**

Use public weather, pollution, or traffic data to predict the next hour or day.

Compare:

- Historical-average baseline
- Linear regression
- Random Forest
- XGBoost
- LSTM or Temporal Fusion model

Then test:

- Different forecasting horizons
- Missing sensor values
- Different cities
- Extreme weather days
- Model performance versus computational cost

A project becomes much more interesting when you answer:

> “When does the deep-learning model actually outperform simpler methods?”

Sometimes the result will be that it does not. That can still be a valid conclusion if the experiment is well designed.

### **5. Offline disaster-report classifier**

Create a small text classifier that categorizes emergency messages into:

- Medical
- Shelter
- Food/water
- Infrastructure
- Transportation
- Safety

The novelty could be:

- Works offline
- Supports multiple languages
- Runs on a low-end laptop
- Handles noisy social-media text
- Compares a small model with a cloud API
- Measures performance when training data is limited

This gives you a complete project:

```plaintext
Dataset→ preprocessing→ baseline model→ improved model→ error analysis→ offline demo→ limitations

```

### **6. Sports analytics with explainability**

Use a public sports dataset to predict match outcomes, player performance, or injury risk.

Do not stop at “my model achieved 87% accuracy.”

Study:

- Whether the model is overfitting to teams or players
- How performance changes over time
- Which features influence predictions
- Whether the model remains useful on a new season
- Whether a simple model performs almost as well

The interesting part is often the analysis, not the sport itself.

## **A simple project structure**

Use this structure for almost any topic:

```plaintext
1. Define the problem  
2. Find one public dataset
3. Implement a simple baseline
4. Implement one stronger method
5. Add one constraint or research angle
6. Compare the results
7. Perform error analysis
8. Build a small demonstration
9. Document limitations
10. Make everything reproducible

```

Your final report should answer:

- What problem are you solving?
- Why does it matter?
- What has already been done?
- What is different about your project?
- What is your baseline?
- What experiment did you perform?
- What failed?
- What are the limitations?
- Can someone else reproduce it?

## **Where to find inspiration**

Use these places for ideas and baselines, not for copying and submitting someone else’s project:

- GitHub project-based-learning repositories
- Build-your-own-X projects
- Devpost and hackathon submissions
- University project archives
- Kaggle datasets and notebooks
- Papers on arXiv and Semantic Scholar
- NASA, NOAA, USGS, and other public-data portals
- Open-source repositories related to your chosen method

NOAA maintains a large collection of openly accessible datasets across weather, climate, ocean, and environmental domains, which gives you many options beyond the usual image-classification datasets. **[National Oceanic and Atmospheric Administration](https://www.noaa.gov/nodd/datasets)**

## **The fastest way to choose one**

Give yourself 30 minutes:

```plaintext
Choose one area→ choose one public dataset→ find two related papers→ read their limitations and future-work sections→ write one research question→ check whether you can build a baseline in one week

```

For example:

> “Can a lightweight model detect wildfire activity from public satellite data while using less memory than a standard CNN?”

That is already a better project direction than:

> “Wildfire detection using deep learning.”

## **What I would avoid**

- Downloading a complete GitHub project and changing the title
- Using ChatGPT to write the entire report without understanding it
- Choosing a dataset before defining the research question
- Reporting only accuracy
- Using a huge model that you cannot explain
- Making medical or security claims your experiment cannot support
- Depending on a paid API for the entire project
- Building a complicated mobile app before validating the model
- Claiming novelty when your only change is the user interface

The safest route is to use an existing implementation as a **baseline** , cite it properly, understand it, and then perform your own experiment.

A strong final-year project could simply be:

> “I reproduced an existing method, tested it on a different dataset or under a realistic constraint, compared it with simpler baselines, analyzed its failures, and built a reproducible demonstration.”

That is much more defensible than submitting a copied “AI project” with a flashy interface.