Anyone who has shipped both an API endpoint and a React component will put "full-stack developer" on their LinkedIn. Which is fine. The problem is the CV. By the time a recruiter has read three full-stack CVs that all list React, Node, Python, Postgres, MongoDB, Docker, AWS, Kubernetes, and "some Go", they stop reading the skills section entirely.

The job of a strong full-stack CV is the opposite of what most candidates write. It's not to prove you've touched everything. It's to make one specific seniority claim — I can own this kind of problem end to end at this kind of company — and let the breadth show up in the supporting evidence.

What recruiters are actually trying to figure out

For a full-stack role, the hiring manager has three questions to answer in 30 seconds with your CV in front of them:

1. What's the heaviest single thing this person has owned? A monorepo migration, a billing system rewrite, an internal tool that 200 people use daily — anything where the candidate is named as the owner, not part of a team of eight.
2. Which side are they actually stronger on? Almost everyone is more comfortable on one side than the other. The CV should reveal which side without you having to say it. A candidate who lists three React state-management libraries but only "familiar with SQL" is telling the truth about themselves whether they meant to or not.
3. Can they ship a feature alone if asked? Solo project bullets — "shipped X end to end" — are the strongest signal. Team bullets get discounted because the recruiter can't tell what part you did.

If your CV doesn't make those three answers obvious in the top half of page one, the rest doesn't matter.

The opening: pick your seniority claim

Full-stack covers a salary range of roughly 2x from junior to staff. The CV has to commit to one band.

The summary at the top of the CV should answer the seniority question in one sentence with a concrete artifact. Bad:

Full-stack developer with experience in modern web technologies, passionate about building scalable applications and clean code.

That reads as a chatbot answer. Compare:

Full-stack engineer (4 years) who owned the customer-billing rewrite at Doctolib — Next.js front, NestJS API, Postgres, deployed on GCP — currently used by 12,000 daily users.

The second one tells the recruiter the seniority (4 years, owned a rewrite), the stack (specific), and the scale (12,000 daily users). It doesn't need the words "passionate" or "scalable" because the artifact does the work.

The skills section: stop listing 30 things

The biggest mistake on full-stack CVs is a skills section that looks like a job board pasted into a CV. React, Vue, Angular, Svelte, Solid, Qwik. Node, Deno, Bun. Postgres, MySQL, SQLite, MongoDB, DynamoDB, Redis. Every framework you've ever opened a tab on.

A recruiter who sees 35 technologies listed assumes either you've used three of them seriously and the rest for an afternoon, or you don't have judgment about what to put on a CV. Either reading hurts.

A better structure has three tiers:

• Primary (3–5 items). The stack you'd happily lead a code review on. "TypeScript, Next.js, Postgres, Node.js, AWS".
• Working knowledge (4–6 items). Things you'd be productive on in a week. "React Native, GraphQL, Redis, Docker, Terraform, GitHub Actions".
• Exposure (skip the list). Don't list these. If a recruiter asks "do you know X", you can say yes. Listing 20 "exposure" tools makes the primary list look weaker.

Three tiers, around 10 items total. Anything more and you're padding.

The experience section: write outcomes, not stacks

The most common full-stack bullet pattern is:

Developed and maintained features using React, Node.js, Express, MongoDB, AWS Lambda, and Docker.

This says nothing. Six technologies, one verb ("developed"), no outcome. The recruiter has no idea what you built, how big it was, or whether anyone used it.

The replacement pattern that works:

Shipped the multi-tenant billing flow (Stripe + custom invoicing) end to end — TypeScript/NestJS API, React/Next.js admin UI, Postgres with row-level security. Took the system from spreadsheet-based to self-serve, cut finance ops time by 60% (12 hours/week to 5).

Four things changed:

1. A specific feature instead of "features".
2. "End to end" signals solo ownership, not part of a team.
3. Stack inline with the outcome, not in a separate list at the end.
4. A measurable result with a starting and ending state.

Do this for two or three bullets per role. The remaining bullets can be lighter — they're context, not evidence.

Show the seam

Full-stack means you cross the seam between frontend and backend regularly. The CV should prove it.

• One bullet that talks about a frontend decision with backend implications ("redesigned the search UI to drop client-side filtering once the dataset crossed 5k rows, moved aggregation to a Postgres materialized view").
• One bullet that talks about a backend decision with frontend implications ("rewrote the contracts API to return paginated cursors instead of offsets, lets the React table do infinite scroll without re-fetching").
• One bullet about a deployment, infrastructure, or DX improvement if you have one ("set up preview environments per PR, reduced manual QA cycles from 2 days to same-day").

The combination tells the recruiter you actually think across layers, not just that you've written code in two languages.

Projects: the silent tiebreaker

For full-stack candidates with less than five years of experience, the projects section often does more work than the experience section. Hiring managers look there to see what you build when nobody's paying you to build it.

What earns a slot:

• A project you can demo at a public URL.
• A repo on GitHub that's actually maintained — commits in the last 6 months, a real README, issues responded to.
• One sentence on why you built it (a specific problem you had, not "to learn React hooks").
• The actual stack inline.
• A scale number if there is one (users, stars, downloads).

Two projects with depth beat five with none. Cut anything that's a tutorial follow-along.

What to leave off

• "Familiar with" or "basic understanding of". If you have to qualify it, leave it off. Recruiters read it as "can't actually use".
• Years of experience per technology. Listing "React (5 years)" is the kind of LinkedIn-skills game that nobody hiring takes seriously anymore.
• Methodology tags as skills. "Agile", "Scrum", "TDD" in the skills list takes up space and proves nothing. If you've done them, they show up in your experience bullets.
• The full list of every cloud service you've touched. AWS Lambda, S3, EC2, RDS, SQS, SNS, CloudFront, Route 53, IAM. Pick the two or three you actually owned and let the rest be implied.
• GPA, university courses, secondary school. None of these change a senior recruiter's mind about a full-stack candidate with even a year of professional experience.

A small structural tip

The order that works for most full-stack CVs at 2–7 years of experience is: summary → key skills (3 tiers, compact) → professional experience (most recent first, bullets in the format above) → notable projects (2–3) → education → languages. Certifications only if they're substantial (AWS Solutions Architect Pro, Kubernetes CKAD); skip Coursera completions.

If you're generating your CV from your LinkedIn profile in a tool like Postulit, the default output will lean broad — that's fine for a first pass. The work is then cutting the skills list down to your primary stack, rewriting two or three experience bullets to follow the format above, and adding one or two demo links. Twenty minutes of edits on top of the generated draft makes the difference between "another full-stack CV" and a CV that gets called.