AI Generalist Portfolio Projects: 15 Shippable Ideas

These projects are ordered by dependency — each earlier one teaches a skill the later ones assume. Pick any ten to ship; the fifteenth on this list, not your first, is what gets the screening recruiter's attention. Every project below has been designed to be deployable on a $5 VPS; salary-positive portfolios are built of live URLs, not notebooks.

1. Exploratory data analysis + prediction on a public dataset

Pick a Kaggle dataset (titanic, housing, bike-sharing) you find interesting. Produce a clean notebook covering: data dictionary, missingness audit, target distribution, univariate + bivariate analysis, baseline (mean predictor), three models with cross-validated metrics, feature-importance discussion, and a one-paragraph 'what I'd do next.' This is the universal first-project of the field — and the #1 place juniors reveal an absence of discipline.

Evaluation rubric (what recruiters check on your GitHub)

• Notebook runs end-to-end from a freshly-cloned repo (reproducibility is not optional)
• Baseline predictor comparison present (the #1 omission in beginner work)
• Train/val/test split with no leakage, documented explicitly
• README with dataset source, installation, and how to re-run
• Commit history tells a story — incremental, not 'initial commit' dumps

2. Tabular classifier behind a FastAPI endpoint

Take the winner from project 1, serialise it (joblib / pickle), and expose it at `POST /predict`. Add Pydantic input validation, a health endpoint, Dockerfile, and docker-compose.yml. Deploy to a VPS. The project that converts notebook-code skills into production-service skills.

Evaluation rubric (what recruiters check on your GitHub)

• Pydantic model validates input shape + types + ranges
• Dockerfile multi-stage; final image < 500 MB
• Live public URL the reviewer can curl against
• Structured JSON logging of request + inference time
• README records the VPS IP, the deploy command, and how rollback works

3. Image classifier fine-tuned from a pretrained CNN

Pick a non-obvious image domain — plant diseases, bird species, sketch categories. Fine-tune resnet50 or efficientnet. Track experiments in W&B. Produce a confusion-matrix analysis and a Grad-CAM interpretability section. Deploy behind FastAPI with a simple Gradio UI.

Evaluation rubric (what recruiters check on your GitHub)

• Data augmentation strategy documented with before/after validation curves
• Grad-CAM or SHAP interpretability section on 5+ misclassified examples
• Learning-rate schedule justified (constant vs cosine vs step)
• W&B report URL in the README
• Gradio demo live; user can upload an image and see the top-3 predictions

4. Text classifier with a Transformer

Fine-tune DistilBERT or ModernBERT on a text classification task — toxicity, sentiment on an underserved language, intent classification from chat logs. Benchmark against a TF-IDF + logistic regression baseline; show where the transformer wins and where it does not.

Evaluation rubric (what recruiters check on your GitHub)

• Baseline comparison present with honest accounting (sometimes the baseline wins)
• Tokenisation pitfalls documented (truncation, max length, padding)
• Confusion matrix + per-class F1 table
• Inference latency measured at batch sizes 1, 8, 32
• Failure-mode analysis — 10 real mistakes discussed in prose

5. RAG Q&A system over a personal document corpus

Build a retrieval-augmented Q&A system over 50+ documents you actually care about (your university syllabi, your saved articles, a public-domain book corpus). Use pgvector on Postgres. Chunk, embed, retrieve, re-rank, answer. Add a Gradio UI and an evaluation set of 30 questions scored by an LLM judge.

Evaluation rubric (what recruiters check on your GitHub)

• Chunk strategy explained (size, overlap, structure-aware splits)
• 30-question eval set with LLM-judge scoring + human spot-check of 5
• Hybrid search (BM25 + dense) implemented or justifiably skipped
• Streaming response in the UI (no 'Loading...' for 30 seconds)
• Prompt injection defense layer — at least input allowlisting

6. Time-series forecasting of a domain you understand

Forecast something you can sanity-check yourself — your local weather, a stock price you follow, energy demand for your city. Compare classical (ARIMA, Prophet) vs gradient-boosted (XGBoost with lag features) vs neural (N-BEATS, Temporal Fusion Transformer). Proper time-series cross-validation. Walk-forward evaluation on the last 90 days.

Evaluation rubric (what recruiters check on your GitHub)

• Time-series train/val/test split (never random) — the leakage checkpoint
• Feature engineering beyond raw lags — rolling stats, calendar, holidays
• MAPE + MAE reported, not just one metric
• Walk-forward evaluation with 90-day horizon
• Discussion of failure windows — where each model breaks

7. Recommendation system for a niche taste graph

Movies / books / music / recipes — pick one and build a recommender. Implement content-based, collaborative filtering, and a hybrid. Evaluate with precision@k, recall@k, and NDCG. Bonus points: cold-start strategy for new users.

Evaluation rubric (what recruiters check on your GitHub)

• Three algorithm families implemented + compared honestly
• Precision@k, recall@k, NDCG@10 reported
• Cold-start strategy written up — even if it's just 'popularity fallback'
• Offline A/B of two recommenders with real evaluation set
• Live demo where you can click 'I like X' and get updated recommendations

8. LLM function-calling agent with a narrow job

Build an agent that does one thing well — books calendar slots, drafts shell commands, summarises your pull requests. Expose 3-5 tools via the provider's function-calling API. Add a safety layer: dry-run before destructive operations, confirmation prompts, output bounds. Resist the urge to make it do ten things.

Evaluation rubric (what recruiters check on your GitHub)

• Task scope explicitly narrowed — README has an 'out of scope' section
• Dry-run flag for every destructive tool
• Tool-call log persisted + inspectable (the #1 debugging surface)
• Prompt + tool-schema live in their own files — not inlined in the Python
• Failure modes documented — where the agent loops, hallucinates, or gives up

9. Anomaly detection on real production-like data

Use a server-log dataset, credit-card fraud set, or an industrial IoT dataset. Implement isolation forest, one-class SVM, and an autoencoder-based anomaly scorer. Address the heavy class imbalance honestly — oversampling, undersampling, class weights, or cost-sensitive learning.

Evaluation rubric (what recruiters check on your GitHub)

• Class-imbalance strategy chosen + justified
• Precision-recall curve present (ROC alone is misleading under imbalance)
• Cost-sensitive evaluation (false-negatives weighted realistically)
• Comparison of three algorithms with honest trade-off discussion
• Live inference endpoint streaming results for a sample of incoming events

10. End-to-end Kaggle-style submission, public writeup

Pick an active Kaggle competition or a Hugging Face leaderboard task. Do the full cycle — EDA, baseline, iteration, ensembling, submission. Publish your approach as a Kaggle kernel or blog post. Top-50% finish is a respectable outcome; top-10% is a strong hiring signal. The public writeup is often as valuable as the rank.

Evaluation rubric (what recruiters check on your GitHub)

• Final rank documented honestly, including what did not work
• Reproducibility — a competition-winner's notebook runs in under 30 min
• Ensemble strategy explained beyond 'I averaged three models'
• Writeup published on Kaggle Discussions or a blog, minimum 1500 words
• The README links the rank + writeup + notebook

11. Public-data dashboard with LLM-generated insights

Take a public API (OpenWeather, Github Stars, a government open-data portal) and build a live dashboard that refreshes hourly. Surface a one-paragraph LLM-generated narrative of what changed. This project demonstrates three skills at once: ETL, visualisation, and LLM prompt engineering for structured output.

Evaluation rubric (what recruiters check on your GitHub)

• Scheduled refresh documented — lives past your attention
• LLM prompt is cached on inputs so you don't burn API cost per page load
• Structured-output validation — the LLM's response gets Pydantic-parsed before display
• Failure mode: what shows when the API is down or the LLM errors?
• Deployed to a VPS or Railway / Fly, not just running locally

12. Re-implementation of a canonical paper in ≤ 500 lines

Pick a paper you care about — 'Attention Is All You Need', 'BERT', 'CLIP', 'Denoising Diffusion Probabilistic Models', 'Mamba'. Re-implement its core algorithm from scratch in PyTorch in under 500 lines. Train on a toy dataset. Publish a blog post explaining every non-obvious decision. This project cuts your claimed 'I know transformers' from vague to defensible.

Evaluation rubric (what recruiters check on your GitHub)

• Paper citation + exact section-by-section mapping in the README
• Toy-dataset training curves that clearly converge
• Code reads like prose — no 4000-line files, no hidden magic
• Blog post walks through the math in plain language
• Comparison against the Hugging Face reference — yours should match within rounding on a small model

13. Open-source contribution to a library you use

Pick a library in your stack — Hugging Face, FastAPI, scikit-learn, LangChain. Find a good-first-issue or reproduce a bug you have hit. Submit a PR. Survive the review. Ship it. One merged PR to a real library outranks five solo side projects for many hiring signals.

Evaluation rubric (what recruiters check on your GitHub)

• PR is merged (un-merged PRs don't count until they are)
• You wrote a test that fails on main and passes on your branch
• You respond to reviewer feedback within 48h, professionally
• Commit message follows the project's convention
• README on your profile links the merged PR

14. Integration project: classic ML + LLM, deployed end-to-end

Capstone. Build something that uses classical ML as the reliable backbone and LLM as the flexible interface — example: a resume parser that uses a trained NER model for extraction and an LLM for rewriting, a triage system that routes tickets via a classifier then summarises the top five via LLM, or a pricing assistant that uses XGBoost for the number and an LLM for the explanation. Deployed, documented, evaluated. This is your graduation project.

Evaluation rubric (what recruiters check on your GitHub)

• Architecture diagram in the README — one image, clear boxes
• Classical + LLM roles justified per-subsystem — no 'let's throw an LLM at it all'
• Cost + latency budgets documented per request
• End-to-end eval set + metrics
• Live URL. A recruiter should be able to use it in under 60 seconds.

15. Teaching artifact — write-up or video tutorial

Teach one thing you learned in the last month, clearly, in public. A 1500-word blog post, a 10-minute YouTube video, or a well-illustrated Twitter thread. Teaching is the forcing function that turns 'I ran the tutorial' into 'I understand this.' Your teaching history is a de-facto hiring dossier.

Evaluation rubric (what recruiters check on your GitHub)

• Draft circulated to one reviewer before publish
• Opens with the problem, not the answer
• Every claim is either demonstrable or cited
• You answer the first wave of comments/questions — publish and disappear is a failure state
• You publish at least three of these over your learning year

Frequently asked questions