The 3-Project AI Engineering Portfolio That Gets You Hired

What actually gets you hired

The old portfolio advice — twenty repositories, a wall of certificates, a personal site listing every tutorial you have ever completed — is now working against you. As of mid-2026, the people hiring AI engineers in India and the UK do not read any of that. They open your links, they look for evidence that you can put a language model into production and keep it running, and they decide within a couple of minutes. Your profile and the links on it are your proof-of-work. Three excellent, deployed projects beat twenty half-finished ones almost every time.

This guide is a durable method, not a trend chase. The specific models will change; the shape of the portfolio will not. Build these three projects well, deploy them somewhere a reviewer can click, document them as if a stranger has to trust them, and make them findable. That is the whole play, and it will still be the play eighteen months from now.

• Three, not twenty. You do not need twenty projects; you need three to five excellent, deployed ones — two or three polished builds with strong READMEs beat ten unfinished repositories.
• The three that matter. A RAG system over your own documents, an agent that completes a real task end to end, and an evaluation harness that proves the first two work. Together they cover the full arc of production AI.
• Deployed beats described. A live demo a reviewer can click — reachable from Bengaluru and Bristol alike — is worth more than any paragraph on a CV.
• Production signals win. Hiring managers scan your links for error handling, evaluation and deployment — not model cleverness.
• The eval harness is the seniority tell. Anyone can wire up an API call. The engineer who writes a golden set and regression tests is the one who stands out for a senior offer.
• Make it findable. The best portfolio in a private repository hires nobody. It has to be public, linked and searchable to the people doing the hiring.

Why hiring went links-first

For most of the last decade, a CV plus a tidy GitHub grid was enough to get an interview. That has quietly collapsed. The reason is simple: foundation models made it trivial to talk about building with AI, so talk stopped being a useful signal. Everyone's CV now says "experience with LLMs, RAG and agents". The only way a hiring manager can separate the people who have genuinely shipped from the people who have watched a video is to look at the artefact itself. So they ask for the link, and they judge what is behind it.

In practice this means recruiters and engineering managers increasingly ask for a GitHub profile and a live-demo URL in place of, or ahead of, a CV — and when they open those links they are not admiring your code style. They are scanning for the unglamorous markers of someone who has felt production hurt: does the service handle a malformed input without crashing, is there any evaluation at all, is it actually deployed or does it only run on the author's laptop. Those three — error handling, evaluation, deployment — are the production signals that decide the shortlist. A gorgeous model with none of them reads as a student project. A modest model wrapped in all three reads as a colleague.

This shift is good news if you are switching in from an adjacent discipline, because it rewards exactly the habits you already have. If you are moving across from a server-side role, the instinct for retries, timeouts, idempotency and observability is worth more here than any amount of model theory; our guide to breaking into AI engineering from a backend role maps that transfer directly onto these three projects. If you are coming from analytics, the discipline of measurement is your edge — the data-science-to-LLM-engineer roadmap shows how to convert it into shipped software. Either way, the links-first market is not asking you to be a researcher. It is asking you to prove you can deploy.

One more thing the links-first world changed: geography stopped gating opportunity the way it used to. A hiring manager at a London lab or a Bengaluru global capability centre can assess a candidate anywhere purely from a working demo. That cuts both ways — you are now competing with more people, but you can also be found by employers you would never have reached with a CV. The builders who win in this environment are the ones whose proof is visible, clickable and honest about what it does.

Project 1 — RAG over your own documents

Start here, because retrieval-augmented generation remains the most in-demand skill in the 2026 market. Nearly every enterprise AI project is, underneath, a RAG problem: ground a model in the organisation's own data so it answers from source rather than from imagination. If you can build one well, you can build the core of most real products.

The trap is that RAG is also the most tutorialised topic in AI, which means a generic "chat with a PDF" clone proves nothing — the reviewer has seen a thousand of them. The way to stand out is to build over a corpus you actually care about and can speak to credibly: your own notes, a public regulatory dataset, a body of research papers in your field, a documentation set for a tool you use. Real data forces real decisions, and real decisions are what a reviewer is looking for.

What you build matters less than what you can show. Three artefacts turn a toy into evidence:

• A retrieval evaluation. Assemble a small labelled set of questions and the passages that should answer them, then measure recall@k and report the number honestly. This single act separates you from almost every other RAG portfolio, because it proves you understand that retrieval quality — not the model — is where these systems live or die.
• A defended chunking decision. Show that you tried more than one chunking and embedding strategy and chose based on the evaluation, not vibes. A short table of "chunk size 512 vs 1024, recall went from 0.71 to 0.83" is worth more than a paragraph of prose.
• A live demo. Deploy it on a free tier — a small container, a serverless function, a hosted notebook — and make sure the URL loads quickly from both India and the UK. A reviewer in Manchester and one in Hyderabad should both get a fast, working page.

Structure the repository so a stranger can understand it in thirty seconds. A clean skeleton signals production thinking before anyone reads a line of logic:

rag-over-docs/
├── README.md            # Problem, corpus, architecture, eval results, live demo link
├── ingest/
│   └── loader.py        # Chunking + embedding; retries and rate-limit handling
├── retrieve/
│   └── search.py        # Vector search; returns sources with every answer
├── eval/
│   ├── golden_set.jsonl # ~50 labeled question → answer-passage pairs
│   └── recall.py        # recall@k on the golden set — the number reviewers want
├── serve/
│   └── app.py           # The live demo a reviewer can click
└── deploy/              # Dockerfile / compose — reproducible, not "works on my machine"

Notice there is an eval/ folder in a RAG project. That is deliberate, and it is the bridge to Project 3. Grounding the model is half the job; proving the grounding works is the other half, and the candidates who show both are the ones who convert a first screen into an offer.

Project 2 — an agent that does a real task

The second project shows you can build something that acts, not just answers. An agent — a model given tools, a loop and a goal — is the pattern behind the fastest-growing roles in the field, and it is where a lot of 2026 hiring is concentrated. The demand for people who can make agents survive contact with the real world is exactly why the forward-deployed engineer role has become AI's hottest job; a working agent in your portfolio speaks straight to that market.

Pick a task that is genuinely useful and genuinely bounded — not "an agent that does anything", which always demos badly, but something concrete a real user would pay for. A triage agent that reads incoming support tickets, classifies them and drafts a reply. A research agent that takes a question, searches a defined set of sources and returns a cited brief. A data agent that connects to an API, pulls records and produces a validated report. The narrower the task, the more convincingly you can make it actually work.

What a reviewer looks for in an agent is not cleverness — it is control. Four things carry the weight:

• Real tool use. The agent should call actual tools — an API, a database, a function — and handle their responses, including the failures. A tool that returns an error, a timeout or garbage is where most agents fall over; handling it is where you stand out.
• Guardrails. Show the boundaries you put in place: input validation, a cap on loop iterations so it cannot spin forever, a refusal path for out-of-scope requests, and a human-in-the-loop checkpoint before any irreversible action. Guardrails signal that you have thought about what happens when the model is wrong.
• Observability. Log every step — the plan, the tool call, the result, the decision. When a reviewer can open a trace and follow what the agent did and why, they trust it. When they cannot, they assume it is luck.
• A failure-handling story. Document one real thing that broke and how you handled it — the API that rate-limited you, the tool that returned a malformed record, the loop that got stuck. This is the single most convincing thing in an agent portfolio, because it proves you have operated the thing, not just built it.

Project 3 — the eval harness that signals seniority

This is the project almost nobody builds, which is exactly why it is the one that most sets you apart for a senior offer. An evaluation harness is a small system that answers a deceptively hard question: is my AI actually working, and did my last change make it better or worse? Building one tells a hiring manager that you think like an engineer who owns a system in production, not a hobbyist who ships once and hopes.

An eval harness has three parts, and you can build it on top of Project 1 or Project 2 so it does double duty:

• A golden set. A curated collection of inputs paired with the correct or ideal outputs — fifty is plenty to start. Assembling it by hand is the work; it forces you to define what "good" even means for your system, which is the thing most people skip.
• An LLM-judge. For outputs that are not exact-match — a summary, a drafted reply, a research brief — use a separate model to score each output against the reference on a defined rubric. Show that you validated the judge against a few of your own human ratings so it is not just marking its own homework.
• Regression tests. Wire the whole thing into a test suite that runs on every commit, so a prompt tweak or a model swap that quietly degrades quality fails loudly before it ships. This is the move that reads as seniority.

The code does not need to be elaborate. A reviewer wants to see the discipline, not a framework:

# eval/test_regression.py — runs in CI on every commit
GOLDEN = load_jsonl("eval/golden_set.jsonl")   # 50 hand-labeled cases

def test_retrieval_recall():
    hits = [retrieve(c.question, k=5) for c in GOLDEN]
    recall = mean(c.answer_doc in h for c, h in zip(GOLDEN, hits))
    assert recall >= 0.85, f"recall@5 regressed to {recall:.2f}"

def test_answer_quality():
    for c in GOLDEN:
        answer  = pipeline(c.question)
        verdict = judge(question=c.question, answer=answer, reference=c.answer)
        assert verdict.score >= 4, f"LLM-judge gave {verdict.score}/5 on {c.id}"

With the three projects in place, it helps to see how each earns its keep. This is the table to keep in your head while you build:

The README and demo standard

Two candidates can build the same three projects and get wildly different results, and the difference is almost always presentation. The code is table stakes; the README and the demo are what a hiring manager actually reads. Treat the README as the most important file in every repository, because for most reviewers it is the only file they will read in full.

A README that gets you hired opens with the problem in plain English, not the tech stack. It states what the project does and for whom, then shows the result — a screenshot, a short clip, or best of all a live link — before it ever mentions a library. It explains the architecture and, crucially, the trade-offs you made and why. It reports the numbers: the recall figure, the eval score, the latency. And it ends with what you would do next, which is how a senior engineer signals that they know the work is never finished. An excellent README is one of the strongest signals a reviewer weighs when deciding whom to shortlist, precisely because it is rare.

The demo standard is just as unforgiving. It must be deployed, it must load quickly from both India and the UK, and it must not fall over on the first odd input a curious reviewer throws at it. Put it behind a free tier, keep it warm enough to respond, and test it from a phone on a different network before you call it done. A dead demo link is worse than no link at all — it reads as carelessness on the one thing you controlled completely.

There is one more signal that is quietly decisive: your commit history. Consistent, incremental commits over several months beat a frantic burst of activity right before you apply, because the pattern tells a hiring manager how you actually work. A history that shows a project growing steadily — a feature here, a bug fix there, an eval improvement next week — reads as a real engineer maintaining a real system. A single giant commit dated three days before your application reads as exactly what it is. Start these projects early, work on them in the open, and let time do some of the arguing for you.

How to present it — one profile that links all three

You have now done the hard part. The three projects exist, they are deployed, the READMEs are honest and the commit history is real. Everything now depends on one move: putting all of it in a single place that the people hiring actually look at. A hiring manager will not assemble your story from a scattered GitHub, a half-finished personal site and a LinkedIn headline. You have to hand them the assembled story — the three demos, the three READMEs, and a line on each that says what it proves — in one link.

That is precisely what a Verified Builder profile on AI Tech Connect is for. It is the page where your RAG system, your agent and your eval harness sit together, each with its live demo and its architecture brief, and where the whole thing becomes searchable to the labs, consultancies, global capability centres and funded startups hiring AI engineers across India and the UK. Instead of cold-applying into an inbox and hoping, you become discoverable to employers who are actively looking for exactly what you have built. This is the same evidence-first mechanic that lets people land their first AI consulting clients: a documented, visible body of work does the arguing for you.

And there is a genuine, time-limited advantage in claiming your place early. Early profiles carry the Founding Builder badge, and the number of those spots is limited. This is not a manufactured urgency; it is how the directory is built. In a market this hot and this short of trustworthy ways to verify that someone can actually deploy, being an early, visible, evidence-backed profile is a compounding edge — the badge, the head start in search, and the credibility all accrue to the people who move first, and they stop being available once the founding spots fill. If you have built even one of these three projects, that is enough to claim your profile now and grow it as the other two land.

When the conversations start — and with a portfolio like this they will — walk in knowing your worth. The bands differ sharply between the two markets, and converting a headline figure from one to the other is a fast way to negotiate badly; our India and UK pay benchmark and negotiation guide is built to handle exactly that two-tier reality so your proof-of-work translates into the offer it deserves.

Common mistakes, and your next two weeks

Most portfolios fail for a small set of predictable reasons. Avoid these and you are already ahead of the field:

• Chasing volume. Twenty tutorial clones signal that you have never finished anything. Delete or archive them; keep three that are genuinely good.
• Shipping a demo, not a deployment. A notebook that runs on the happy path proves nothing. Show error handling, evaluation and a live URL, or it does not count.
• Skipping the eval harness. It is the one project that reads as seniority and the one almost everyone omits. Build it and you separate yourself instantly.
• A README that opens with the tech stack. Lead with the problem and the result. The reviewer decides in the first paragraph whether to keep reading.
• The pre-application commit burst. A wall of commits three days before you apply fools nobody. Start early and work in the open.
• Doing it all in private. The best work nobody can see hires nobody. Make it public, linked and searchable.

If you want a concrete plan, here is a fortnight that gets you from nothing to a visible portfolio. Week one: build Project 1 over a corpus you care about, write the retrieval evaluation, and deploy the demo. Claim a Verified Builder profile and link that first project the moment it is live — you do not need all three to start, and an early profile secures the Founding Builder badge while it is available. Week two: build the agent (Project 2) over a bounded task, then wrap both under the eval harness (Project 3), committing steadily the whole way. Update your profile as each lands. At the end of two weeks you will have what most applicants never assemble: three deployed projects, honest numbers, a clean history, and a single searchable link that the people hiring across India and the UK can find. That link, not your CV, is what gets you the interview.