Portfolio Project Ideas

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

Classify and cluster news articles into topics.

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

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.

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.

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.

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.

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

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

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.

Classify emails and explain the features that flag spam.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.