66 ideas · 6 domains · datasets included

Portfolio Project Ideas

"No projects" is the #1 reason fresher and switcher resumes get rejected. Here are 66 project ideas across data analysis, classical ML, NLP, computer vision, Generative AI, and MLOps — each with the problem, a real dataset, a suggested stack, and what makes it stand out to recruiters.

📊 Data Analysis & Viz · 11 ideas

Netflix / Spotify viewing-history dashboard

Beginner

Analyze your own exported streaming history to find your top genres, binge patterns, and time-of-day habits.

  • Dataset: Your own Netflix/Spotify data export (request from account settings).
  • Stack: Pandas, Plotly, Streamlit
  • Stands out: Use YOUR data — recruiters remember personal, story-driven projects over Titanic for the 1000th time.

COVID / public-health trend explorer

Beginner

Build an interactive dashboard of case/vaccination trends with rolling averages and per-capita normalization.

  • Dataset: Our World in Data, WHO open datasets.
  • Stack: Pandas, Plotly Dash
  • Stands out: Add correct per-capita and 7-day smoothing — most beginner dashboards show misleading raw counts.

E-commerce sales & cohort analysis

Intermediate

Compute RFM segments, monthly cohort retention, and revenue drivers from transaction data.

  • Dataset: UCI Online Retail dataset, Kaggle e-commerce sets.
  • Stack: Pandas, SQL, Seaborn
  • Stands out: Show a cohort-retention heatmap — it signals real product-analytics thinking.

City Airbnb pricing analysis

Intermediate

Explore what drives listing price (location, reviews, room type) and map it geospatially.

  • Dataset: Inside Airbnb (free city datasets).
  • Stack: Pandas, GeoPandas, Folium
  • Stands out: Geospatial maps + a clear written 'so what' section beat raw charts.

Personal finance / expense analyzer

Beginner

Parse bank/credit-card CSV exports, auto-categorize spend, and forecast monthly burn.

  • Dataset: Your own anonymized bank statements.
  • Stack: Pandas, Plotly
  • Stands out: A rules+keyword categorizer plus a simple forecast shows end-to-end product thinking.

Sports analytics (cricket/football) dashboard

Intermediate

Analyze player/team performance, win probability, and momentum shifts.

  • Dataset: Cricsheet, StatsBomb open data, football-data.co.uk.
  • Stack: Pandas, Plotly, Streamlit
  • Stands out: A win-probability model on top of raw stats turns a dashboard into a story.

World happiness / development indicators

Beginner

Correlate GDP, health, and freedom with happiness scores across countries and years.

  • Dataset: World Happiness Report, World Bank Open Data.
  • Stack: Pandas, Seaborn
  • Stands out: Distinguish correlation from causation explicitly — interviewers probe this.

Stock / crypto market exploratory analysis

Intermediate

Analyze volatility, correlations, and drawdowns across assets with rolling metrics.

  • Dataset: yfinance API, CoinGecko API.
  • Stack: Pandas, yfinance, Plotly
  • Stands out: Avoid the 'I predicted the price' trap — focus on honest risk/volatility analysis.

A/B test analysis toolkit

Intermediate

Build a reusable notebook/app that runs significance tests, power analysis, and CUPED variance reduction.

  • Dataset: Simulated or Kaggle A/B test datasets.
  • Stack: SciPy, statsmodels, Streamlit
  • Stands out: Demonstrating statistical rigor (power, p-hacking guards) is rare and impressive.

Survey / NPS text + score analysis

Beginner

Combine quantitative NPS with theme extraction from open-ended responses.

  • Dataset: Public survey datasets, Kaggle.
  • Stack: Pandas, simple NLP
  • Stands out: Mixing numeric and text analysis shows breadth.

Energy consumption & forecasting EDA

Intermediate

Explore seasonality and build a baseline forecast of household/grid energy use.

  • Dataset: UCI Individual Household Electric Power Consumption.
  • Stack: Pandas, statsmodels, Prophet
  • Stands out: Proper time-series decomposition (trend/seasonality) before modeling.

🤖 Classical ML · 11 ideas

Credit-default / loan risk model

Intermediate

Predict loan default with class imbalance and explain decisions for fairness.

  • Dataset: Home Credit, LendingClub (Kaggle).
  • Stack: scikit-learn, XGBoost, SHAP
  • Stands out: SHAP explanations + a fairness check across groups shows production maturity.

Customer churn prediction

Intermediate

Predict which subscribers will cancel and quantify retention value.

  • Dataset: Telco Customer Churn (Kaggle).
  • Stack: scikit-learn, XGBoost
  • Stands out: Add uplift/threshold analysis tied to a business cost, not just AUC.

House / used-car price regression

Beginner

Predict prices with strong feature engineering and outlier handling.

  • Dataset: Ames Housing, Kaggle used-car listings.
  • Stack: scikit-learn, LightGBM
  • Stands out: A clean feature-engineering writeup beats throwing models at it.

Fraud detection on imbalanced data

Advanced

Detect fraudulent transactions where positives are <0.2% of data.

  • Dataset: Credit Card Fraud Detection (Kaggle).
  • Stack: scikit-learn, imbalanced-learn
  • Stands out: Use PR-AUC, resampling, and a cost matrix — not accuracy.

Customer segmentation (clustering)

Beginner

Segment customers with K-means/DBSCAN and profile each segment.

  • Dataset: Mall Customers, e-commerce RFM data.
  • Stack: scikit-learn
  • Stands out: Translate clusters into named, actionable personas.

Demand / sales forecasting

Advanced

Forecast store-item demand with proper backtesting.

  • Dataset: Rossmann Store Sales, M5 (Kaggle).
  • Stack: LightGBM, Prophet, statsmodels
  • Stands out: Rolling-origin backtesting and quantile forecasts signal real time-series skill.

Recommendation engine (collaborative filtering)

Intermediate

Recommend movies/products via matrix factorization and implicit feedback.

  • Dataset: MovieLens, Amazon Reviews.
  • Stack: Surprise, implicit, scikit-learn
  • Stands out: Evaluate with ranking metrics (recall@k, NDCG), not RMSE alone.

Insurance / medical cost prediction

Beginner

Predict charges and explain key cost drivers.

  • Dataset: Medical Cost Personal (Kaggle).
  • Stack: scikit-learn
  • Stands out: Strong baseline + interpretable coefficients with a clear narrative.

Employee attrition + explainability

Intermediate

Predict attrition and surface the top drivers for HR.

  • Dataset: IBM HR Analytics (Kaggle).
  • Stack: scikit-learn, SHAP
  • Stands out: Frame it as a decision-support tool, not a leaderboard score.

AutoML / model-comparison pipeline

Advanced

Build a reusable pipeline that tunes and compares many models with cross-validation.

  • Dataset: Any tabular dataset.
  • Stack: scikit-learn Pipelines, Optuna
  • Stands out: A clean, leakage-free CV pipeline with hyperparameter search is portfolio gold.

Time-to-event / survival analysis

Advanced

Model time until churn/failure with censored data.

  • Dataset: Lung cancer / customer survival datasets.
  • Stack: lifelines, scikit-survival
  • Stands out: Survival analysis is rarely shown and signals statistical depth.

💬 NLP · 11 ideas

Sentiment analysis with transformers

Beginner

Fine-tune a small transformer for sentiment and compare to a TF-IDF baseline.

  • Dataset: IMDB, Yelp, Twitter sentiment.
  • Stack: Hugging Face Transformers, scikit-learn
  • Stands out: Show the baseline-vs-transformer trade-off (cost vs accuracy).

Resume ↔ job-description matcher

Intermediate

Score resume–JD similarity and surface missing skills (mirrors getjob4u's ATS scanner).

  • Dataset: Public resume + job posting datasets.
  • Stack: spaCy, sentence-transformers
  • Stands out: Directly relevant to recruiting tools — a memorable, useful demo.

News topic classification & clustering

Beginner

Classify and cluster news articles into topics.

  • Dataset: AG News, 20 Newsgroups.
  • Stack: scikit-learn, BERTopic
  • Stands out: BERTopic visualizations look polished and modern.

Named-entity recognition for resumes/medical

Intermediate

Extract structured entities (skills, drugs, orgs) from free text.

  • Dataset: CoNLL-2003, custom annotated set.
  • Stack: spaCy, Hugging Face
  • Stands out: Custom domain NER with an annotation writeup shows data-labeling skill.

Toxic-comment / hate-speech detector

Intermediate

Multi-label classification of toxic content with fairness checks.

  • Dataset: Jigsaw Toxic Comments (Kaggle).
  • Stack: Hugging Face Transformers
  • Stands out: Bias analysis across identity terms is a standout differentiator.

Abstractive text summarizer

Advanced

Summarize long documents and evaluate with ROUGE + human judgment.

  • Dataset: CNN/DailyMail, arXiv summaries.
  • Stack: Hugging Face (BART/T5)
  • Stands out: Honest evaluation (ROUGE limitations) shows critical thinking.

Multilingual / Hinglish text classifier

Intermediate

Handle code-mixed or non-English text robustly.

  • Dataset: Code-mixed social media datasets.
  • Stack: XLM-R, Hugging Face
  • Stands out: Non-English NLP is underexplored — stands out for Indian/global markets.

Question-answering over a document

Intermediate

Extract answers from a passage given a question (extractive QA).

  • Dataset: SQuAD.
  • Stack: Hugging Face Transformers
  • Stands out: Bridges nicely into RAG projects below.

Keyword / keyphrase extraction service

Beginner

Extract the key phrases from articles via TF-IDF, RAKE, and KeyBERT.

  • Dataset: Any text corpus.
  • Stack: KeyBERT, spaCy
  • Stands out: Compare classical vs embedding methods side by side.

Spam / phishing email classifier

Beginner

Classify emails and explain the features that flag spam.

  • Dataset: Enron, SpamAssassin.
  • Stack: scikit-learn, NLTK
  • Stands out: Feature interpretability + a tiny deployed demo.

Customer-support ticket router

Intermediate

Auto-classify and route support tickets to the right team with priority.

  • Dataset: Public support/intent datasets.
  • Stack: Hugging Face, FastAPI
  • Stands out: Framing it as an end-to-end product (API + UI) lifts it above a notebook.

👁️ Computer Vision · 11 ideas

Image classifier with transfer learning

Beginner

Fine-tune a pretrained CNN/ViT on a custom image set.

  • Dataset: Oxford Pets, Food-101, your own photos.
  • Stack: PyTorch, timm
  • Stands out: Use a custom/self-collected dataset to show data-gathering effort.

Object detection (real-time)

Intermediate

Detect and box objects in images/video with YOLO.

  • Dataset: COCO, custom-labeled set (Roboflow).
  • Stack: YOLOv8 (Ultralytics)
  • Stands out: A live webcam demo video in the README is a strong hook.

Face mask / PPE compliance detector

Intermediate

Detect safety-gear compliance in a video feed.

  • Dataset: Roboflow PPE datasets.
  • Stack: YOLO, OpenCV
  • Stands out: A clear real-world use case (workplace safety) resonates with recruiters.

Medical image classification

Advanced

Detect pneumonia/tumors from X-ray/MRI with proper validation.

  • Dataset: Chest X-Ray (Kaggle), ISIC skin lesions.
  • Stack: PyTorch, Grad-CAM
  • Stands out: Grad-CAM heatmaps + honest discussion of clinical risk shows maturity.

OCR document / receipt parser

Intermediate

Extract structured fields from scanned receipts/invoices.

  • Dataset: SROIE, your own scans.
  • Stack: Tesseract / docTR, OpenCV
  • Stands out: End-to-end extraction to JSON is genuinely useful and demoable.

Image segmentation (medical / satellite)

Advanced

Pixel-level segmentation of regions of interest.

  • Dataset: Carvana, satellite land-cover datasets.
  • Stack: PyTorch, U-Net, segmentation-models
  • Stands out: Segmentation is harder than classification and signals depth.

Pose estimation fitness coach

Advanced

Count reps and check exercise form from webcam pose keypoints.

  • Dataset: Live webcam + MediaPipe.
  • Stack: MediaPipe, OpenCV
  • Stands out: Interactive real-time apps are memorable in portfolios.

Image similarity / visual search

Intermediate

Find visually similar products via embeddings + ANN.

  • Dataset: Fashion-MNIST, DeepFashion, product images.
  • Stack: PyTorch, FAISS
  • Stands out: Connects CV with retrieval systems — bridges to recsys.

Handwritten / scene-text recognition

Intermediate

Recognize digits/characters in noisy real-world images.

  • Dataset: MNIST → SVHN → custom.
  • Stack: PyTorch
  • Stands out: Progressing from clean MNIST to messy SVHN shows real generalization.

GAN / diffusion image generator

Advanced

Train or fine-tune a generative image model on a niche domain.

  • Dataset: Domain image sets (logos, art, faces).
  • Stack: PyTorch, diffusers
  • Stands out: Fine-tuning Stable Diffusion (LoRA) on a niche set is eye-catching.

Plant-disease / crop classifier (mobile)

Intermediate

Classify leaf disease and deploy to run on-device.

  • Dataset: PlantVillage.
  • Stack: PyTorch, ONNX / TF Lite
  • Stands out: On-device deployment (mobile/edge) is rarely shown by juniors.

✨ Generative AI / LLM · 11 ideas

RAG chatbot over your own docs

Intermediate

Answer questions over a PDF/website corpus with citations and low hallucination.

  • Dataset: Your own docs / a public corpus.
  • Stack: LangChain or LlamaIndex, a vector DB, an LLM API
  • Stands out: Add source citations + a 'refuse when unsure' guard — most RAG demos skip this.

Talk-to-your-PDF / research assistant

Beginner

Upload a PDF and chat with it; summarize and extract key points.

  • Dataset: Any PDFs.
  • Stack: LlamaIndex, Streamlit
  • Stands out: A clean uploadable UI makes it instantly demoable to recruiters.

SQL copilot (text-to-SQL)

Advanced

Turn natural-language questions into SQL over a real schema and run them safely.

  • Dataset: Spider, your own DB.
  • Stack: LLM API, SQLAlchemy
  • Stands out: Schema-aware prompting + query validation shows real engineering.

AI agent with tool use

Advanced

Build an agent that plans and calls tools (search, calculator, APIs) to complete tasks.

  • Dataset: N/A (live tools).
  • Stack: LangGraph / function calling
  • Stands out: Agentic workflows are the hottest 2026 skill — show guardrails and traces.

Resume / cover-letter generator

Beginner

Generate tailored resumes/cover letters from a profile + JD.

  • Dataset: User input.
  • Stack: LLM API, FastAPI
  • Stands out: Directly relevant to getjob4u's domain — practical and easy to demo.

Fine-tune a small LLM (LoRA)

Advanced

Parameter-efficient fine-tune an open model on a domain/style.

  • Dataset: Domain instruction datasets.
  • Stack: Hugging Face PEFT, bitsandbytes
  • Stands out: Hands-on LoRA fine-tuning proves you understand training, not just APIs.

LLM evaluation harness

Advanced

Compare prompts/models on faithfulness, relevance, and cost with LLM-as-judge + human eval.

  • Dataset: Your task's eval set.
  • Stack: Python, an LLM API
  • Stands out: Evaluation rigor is what separates senior GenAI engineers from prompt tinkerers.

Multimodal image-caption / VQA app

Intermediate

Caption images or answer questions about them.

  • Dataset: COCO Captions, VQA.
  • Stack: Vision-language models (Hugging Face)
  • Stands out: Multimodal demos feel cutting-edge and are very shareable.

Voice assistant (STT → LLM → TTS)

Advanced

Build a spoken assistant pipeline end to end.

  • Dataset: Live audio.
  • Stack: Whisper, an LLM API, TTS
  • Stands out: Chaining three models into a smooth UX is impressive systems work.

Prompt-engineering playground

Beginner

Compare prompting strategies (zero/few-shot, CoT) on a task with side-by-side outputs.

  • Dataset: Any task set.
  • Stack: Streamlit, an LLM API
  • Stands out: Documenting what worked and why reads like real applied research.

Content / SEO generation pipeline

Intermediate

Generate, fact-check, and structure long-form content with schema markup.

  • Dataset: Topic prompts.
  • Stack: LLM API, Python
  • Stands out: Adding a fact-check / hallucination-guard stage elevates it above 'call the API'.

🚀 MLOps & Deployment · 11 ideas

Deploy a model as a REST API

Beginner

Serve any trained model behind a documented API with input validation.

  • Dataset: Any model from above.
  • Stack: FastAPI, Pydantic, Docker
  • Stands out: A live deployed URL beats a notebook every time — host it free on Render/HF Spaces.

End-to-end ML pipeline with CI/CD

Advanced

Automate data → train → test → deploy on every git push.

  • Dataset: Any tabular dataset.
  • Stack: GitHub Actions, DVC, MLflow
  • Stands out: Reproducible, automated pipelines are exactly what MLOps roles screen for.

Experiment tracking + model registry

Intermediate

Track experiments, params, and metrics; register and version the best model.

  • Dataset: Any modeling project.
  • Stack: MLflow / Weights & Biases
  • Stands out: Shows you treat models as versioned artifacts, not one-off notebooks.

Real-time inference with monitoring

Advanced

Serve predictions and monitor latency, throughput, and data drift.

  • Dataset: Streaming or simulated traffic.
  • Stack: FastAPI, Prometheus, Grafana, Evidently
  • Stands out: Drift dashboards and alerting are senior-level signals.

Batch feature pipeline / feature store

Advanced

Compute and serve features consistently for training and inference.

  • Dataset: Any event data.
  • Stack: Feast, Airflow
  • Stands out: Solving train-serve skew demonstrates production understanding.

Streamlit / Gradio ML demo app

Beginner

Wrap any model in an interactive web UI anyone can try.

  • Dataset: Any model.
  • Stack: Streamlit / Gradio, Hugging Face Spaces
  • Stands out: The single highest-ROI portfolio move — a clickable demo recruiters can play with.

Dockerized reproducible training env

Intermediate

Containerize training so it runs identically anywhere.

  • Dataset: Any project.
  • Stack: Docker, docker-compose
  • Stands out: Reproducibility is a top complaint in industry — show you solve it.

Model A/B testing / shadow deployment

Advanced

Route traffic between model versions and compare online metrics safely.

  • Dataset: Live/simulated traffic.
  • Stack: FastAPI, feature flags
  • Stands out: Shadow/canary deployment is rarely demonstrated by candidates.

Scheduled retraining + data validation

Intermediate

Automatically retrain on fresh data with schema/quality checks.

  • Dataset: A regularly updating source.
  • Stack: Airflow / Prefect, Great Expectations
  • Stands out: Data-validation gates show you've felt real production pain.

LLM app with cost & latency observability

Advanced

Instrument an LLM app to track tokens, cost, latency, and quality per request.

  • Dataset: Your LLM app's traffic.
  • Stack: LangSmith / OpenTelemetry
  • Stands out: Cost/latency observability is exactly what LLM-product teams need in 2026.

Edge / on-device model deployment

Advanced

Quantize and deploy a model to run on mobile or a Raspberry Pi.

  • Dataset: Any small model.
  • Stack: ONNX Runtime, TF Lite
  • Stands out: Quantization + edge deployment is a niche, high-signal differentiator.