Portfolio Projects That Actually Get .NET Developers Hired

I've reviewed a lot of junior-candidate portfolios from the hiring side of the table, and I'll tell you the uncomfortable truth: most of them are indistinguishable. The same to-do app, the same tutorial movie database, the same README that says "built with ASP.NET Core." Thirty seconds each, next CV. And that's a tragedy, because for candidates without degrees or experience, the portfolio is the entire case — it just has to be built like evidence, not like homework.

Here's what actually makes a hiring manager stop scrolling, from someone who's been the hiring manager.

The reframe: your portfolio answers questions

When I open a candidate's project, I'm trying to answer, in order: Can they actually build something that works? Did they make real decisions, or follow a video? What's it like to read their code? Do they finish things? Every choice below is about answering those questions loudly. Quantity is irrelevant — two or three projects that answer them beat ten that don't.

What to build: real problems, small scope

The single biggest upgrade is building something that solves a real problem you or someone you know actually has — because real problems force the decisions tutorials make for you, and give you honest material to discuss in interviews.

Ideas with proven interview mileage (adapt to your life, don't copy verbatim):

  • A booking/scheduling system for a real small business — a barber, a tutor, a sports club. Forces: auth, roles, time-zone-and-clash logic, email notifications, an admin view. Classic enterprise shape — exactly what .NET shops build daily.
  • A domain tracker from your previous career. Ex-retail? Stock and reorder alerts. Ex-finance? Invoice reconciliation. Ex-warehouse (mine): receiving, bin locations, and stock counts. This weaponizes your background — you'll discuss the domain with genuine authority, which is what working with business stakeholders is like.
  • An integration dashboard — pull from two or three public APIs (weather + load-shedding schedules + your calendar is a very South African hit), normalize the data, cache it sensibly, display it. Forces: HttpClient discipline, resilience when APIs fail, background refresh — real production concerns.
  • A small tool with real users — a Discord bot for a community you're in, a WhatsApp-adjacent notifier, a browser extension. "It has 30 users and I fixed bugs they reported" is a sentence that outranks any tech-stack list you could write.

Avoid: anything you can't explain line-by-line, direct tutorial clones (interviewers recognize them instantly), and half-finished "big ideas." A small finished thing beats a grand abandoned one, every time — finishing is the demonstrated skill.

The non-negotiables for every project

These are the difference between "student exercise" and "junior engineer's work":

  1. Deployed and clickable. A live URL I can open changes everything — most candidates don't have one, so you instantly stand out. Azure App Service free tier, Fly.io, Railway; SQLite or a free Postgres tier if the database is the blocker. "Clone it and run migrations locally" means I will never see it run. Sad, but true — I have forty CVs to get through.
  2. A README that sells and explains. Screenshot at the top, live link, three sentences on what it does and why, tech stack, one architecture note ("why I split it this way"), and honest "what I'd improve." The README is the first code-adjacent writing of yours I read; write it like documentation for a teammate.
  3. Real data modeling. More than two tables, actual relationships, a decision or two you can defend ("I denormalized this because..."). CRUD on a single table proves nothing about the job.
  4. Tests where they matter. Not 100% coverage theater — a focused test project on the business logic (the clash-detection, the reorder calculation) with good names. On panels I've sat, any meaningful tests put a junior in roughly the top 10% instantly.
  5. Git history that shows work. Small commits with sensible messages over "initial commit" + "final version". I always click the commit history — it's the closest thing to watching you work.

Make it .NET-shop shaped

If you're targeting the C#/.NET market specifically (in South Africa, that's the enterprise mainstream), let your flagship project mirror the architecture those teams live in: an ASP.NET Core Web API + EF Core + SQL backend with a clear separation between endpoints and business logic, DI used idiomatically, async throughout, validation and consistent error responses (ProblemDetails — it'll come up), and a simple frontend (Razor Pages or a small React app — the backend is the star for these roles). Add structured logging and you're presenting the exact anatomy of the systems you're asking to work on.

One more multiplier: a short "engineering decisions" section in the README — three honest paragraphs on a trade-off you made, a bug that hurt, and what you'd redo. This is catnip for senior reviewers, because reflecting on decisions is the core behavior we're hiring for at every level.

Presenting it: where portfolios go to be seen

  • CV: top third, "Projects" with live links — above education, especially if switching careers.
  • GitHub profile: pin the best three; write the profile README; make sure the pinned repos are the polished ones (I judge the first thing I click).
  • LinkedIn: post short build-updates as you go. Recruiters in the SA market genuinely do find candidates this way, and "documented learning in public" reads as motivated.
  • Interviews: rehearse a five-minute walkthrough of your flagship — the problem, a live demo, the data model, the hardest bug, what you'd change. Question 6 in every junior interview is "tell me about something you built"; be the candidate who's delighted to answer.

The honest timeline

A flagship project done to this standard is 6–10 weekends of work, and it will feel slow next to grinding out five tutorial clones. Do it anyway. On the other side of the table, I promise you: one project that's deployed, tested, honestly documented, and yours is the strongest signal a degreeless CV can carry. It was mine.

Where to go next