Portfolio projects for freshers
Entry-level postings ask for experience you have not had a chance to get. A finished project, graded against a rubric you could read before you started, is evidence you can show instead. 36 briefs across 12 roles, free to read.
How the grading works
- The rubric is published before you build. Every brief lists the criteria and their weights upfront, so you know what you are being measured on.
- Your submission is scored against that rubric. You get a score out of 100, a per-criterion breakdown, written feedback, and three resume bullets.
- Then you defend it in your own words. Four questions generated from your own submission. Using AI to build the project is fine and never costs you points — being unable to explain what you built is what costs you.
Frontend Developer
Build an accessible analytics dashboard
A dashboard that a keyboard-only user and a screen reader user can both operate — the single most common gap in junior frontend portfolios.
Build an e-commerce product page from a design
A single product page built pixel-for-pixel from a real design file, on a real network — the layout, image, and font decisions that separate a fast page from a Lighthouse warning.
Build a multi-step onboarding form that survives a refresh
A three-step signup form where losing progress on refresh is the bug that gets a resume thrown out — state management and validation are the actual skill being tested here, not the visual design.
Backend Developer
Build an authentication API with refresh tokens
A signup/login API with real password hashing and token rotation, not a tutorial's plaintext-and-JWT shortcut.
Build a background job queue with retries and a dead-letter list
An API that accepts jobs and processes them asynchronously — the retry and failure-handling logic is the actual test, not the happy path.
Build a high-write analytics endpoint with aggregated reads
An event-ingestion endpoint built to survive real write volume, plus a read endpoint that aggregates correctly — the two halves of any analytics feature.
Full Stack
Build a multi-tenant SaaS dashboard
A logged-in dashboard where every user sees only their own account's data — the scoping bug that causes the most common real SaaS security incident.
Build a role-gated admin CMS for blog content
An admin panel with a publish workflow and two roles — the access-control bug here is enforced correctly on the server, not just hidden in the UI.
Build a subscription lifecycle with mock billing
Plan changes, a webhook handler, and billing history — the idempotency and edge-case handling here is what real billing code is actually graded on.
DevOps
Containerize and deploy an app to a live URL
Turning an existing app into a properly built, small Docker image and getting it live on a real host — the actual entry-level DevOps skill almost every posting lists.
Build a CI pipeline that actually fails on a broken PR
A GitHub Actions pipeline for lint, test, and build — proven by intentionally breaking a test and watching the pipeline correctly go red.
Instrument an app and build an alert that actually fires
Metrics, a Grafana dashboard, and an alert rule proven to trigger by deliberately breaking the app — visibility that's tested, not just built.
AI Engineer
Build a document Q&A tool grounded in retrieval
A RAG app that answers only from the uploaded document and cites its source — proven by asking it something the document doesn't cover.
Build a resume feedback tool with reliable structured output
A tool that scores a resume against a job description and returns structured, specific feedback — the hard part is the output being reliably parseable, not the prompt idea.
Build an eval harness to compare two prompt versions
A way to prove a prompt change actually improved things, instead of shipping on vibes — the actual daily question at any real AI product team.
Data Scientist
Build a churn prediction model and evaluate it correctly
A churn model on a real public dataset — graded on evaluation choices under class imbalance, not just on training a model.
Build a time-series forecast that beats a naive baseline
A forecast evaluated the way a real team would evaluate it — against a naive baseline, with a time-respecting split, not a random one.
Analyze an A/B test and give a ship or no-ship recommendation
A real experiment-analysis writeup that checks test validity before trusting the p-value — the actual daily job of a product data scientist.
Product Manager
Turn a one-line feature request into a real PRD
A vague ask like "add dark mode" rewritten as a full PRD — graded on whether it reasons from the user problem, not straight to the solution.
Prioritize a messy feature list with a named framework
6-8 realistic candidate features scored with RICE (or similar) — graded on whether the reasoning is consistent and defensible, not the framework name-drop.
Write an evidence-based teardown of a real product
A structured critique of a product you don't own — the grade hinges on whether every claim has a screenshot behind it, not on having a strong opinion.
UI UX Designer
Redesign a real app's onboarding flow to fix one named problem
A before/after redesign of an existing app's onboarding, judged on whether the fix actually addresses the stated problem, not on visual polish alone.
Build a design system foundation with tokens and one full component
Color, type, and spacing tokens plus one fully-specced button — the deliverable an engineer could actually build from without guessing.
Run a usability study and synthesize prioritized recommendations
A real study with real participants on a real interface — graded on whether the test script is unbiased and the findings are evidenced, not summarized from memory.
QA Engineer
Build an automated smoke suite that's reliable, not just present
5 critical flows automated in Playwright or Cypress — graded harder on reliability and failure diagnostics than on raw coverage.
Build an API test suite that covers negative cases and asserts on real content
Happy paths, validation errors, auth failures, and edge cases against a real API — graded on whether assertions check the actual response, not just the status code.
Write a release runbook and prove it works with a real dry run
A rollback plan and go/no-go criteria specific enough to use at 2am — validated by actually walking through it once, not just written.
Android
Build a habit tracker with local persistence and streaks
Add, track, and persist daily habits — a small app, but the streak logic across day boundaries is the actual test.
Build an offline-first notes app with sync and conflict handling
Notes that work with the network off and sync visibly when it returns — including what happens when the same note changed in both places.
Build a job application tracker backed by a real REST API
A thin client over a REST API with pagination and every UI state handled — the actual daily shape of most real Android apps.
iOS
Build a portfolio showcase app with proper SwiftUI navigation
A list-to-detail projects app with one genuinely reusable custom component — proof of composition, not just stock List rows.
Build an offline task app with correctly scheduled local notifications
A to-do app persisted with SwiftData, where deleting or editing a task correctly cancels and reschedules its notification — the actual edge case that breaks junior submissions.
Build a REST-API-backed tracker with async/await networking
A native iOS thin client over a REST API — the actual daily shape of the job, graded on whether errors are surfaced instead of silently swallowed.
Cyber Security
Review a deliberately vulnerable app and write findings a stakeholder can act on
A security review of OWASP Juice Shop or DVWA run locally — graded on whether findings are proven with real repro steps and specific fixes, not a generic checklist.
Set up an isolated home lab and document a full recon-to-exploit walkthrough
A properly isolated lab against a deliberately vulnerable VM (Metasploitable2) — the network isolation is graded as strictly as the exploitation itself.
Write a full incident report from a simulated log-based scenario
A desk exercise: reconstruct a timeline from synthetic logs and write the report a SOC analyst would actually produce after a real incident.
Build one, get it scored.
Pick a brief above, submit your work, and get a score on every criterion, written feedback, and three resume bullets you can use straight away.