How do you verify GitHub contributions without trusting self-reported skills?

I’ve been thinking about a problem that doesn’t get talked about enough in hiring: the gap between what someone claims about their work on linkedin and what they actually did.

Anyone can list “open source contributor” on their resume. Anyone can paste a GitHub repo URL in a portfolio. But without looking at the actual commit history and contributor data — you have no idea if that person wrote 80% of the codebase or merged one typo fix three years ago.

So I started building a system to verify this properly. Here’s what I learned — without giving away the methodology we use, because honestly, the moment you publish your exact algorithm, people optimize for it rather than actually doing the work.

The naive approach fails immediately

The first instinct is to just check if the person’s GitHub handle appears in the contributor list. Simple, right?

Not quite. Three problems come up immediately.

People have multiple GitHub accounts. Work account, personal account, old account from college. A developer might have significant contributions spread across two or three handles. Checking one handle misses the full picture.

Contribution depth varies wildly. Being listed as a contributor could mean 2,000 commits or 1 commit. The contributor list alone doesn’t tell you which. You need actual commit counts per author to understand the depth of contribution.

Public repos can be submitted by anyone. I can submit any famous open source repo to a portfolio system and imply I contributed to it. Without verifying my actual handle against the contributor data, the system has no way to know if I wrote the core architecture or just starred the repo.

What actually works — the principles

I’m not going to share the exact scoring formula. But I can share the principles that make verification meaningful.

Verify account ownership first

Before you can verify contributions, you need to verify identity. The only reliable way to confirm someone owns a GitHub account is OAuth. When someone authenticates via GitHub OAuth, you get a cryptographic proof of ownership — not a claim.

This is the identity anchor. Every contribution check runs against verified handles only. No claims accepted.

Handle the multi-account reality honestly

Developers legitimately use multiple GitHub accounts. A good verification system needs to support this — each additional account verified through its own OAuth flow.

The critical constraint: one GitHub account should only be linkable to one professional identity. Otherwise the whole system can be gamed by linking someone else’s high-signal account to your profile.

This requires exclusive handle claiming. First claim wins. If a handle is already associated with another profile — it’s blocked. No exceptions.

Contribution depth matters more than presence

There’s a meaningful difference between someone who authored 40% of a codebase and someone who fixed a typo. Both show up in the contributor list. Only one actually shaped the project.

The verification system needs to reflect this distinction. Not all verified contributions are equal. Depth matters. History matters. Consistency over time matters more than a spike of activity.

Unverified doesn’t mean worthless — but it means discounted

Not everything can be verified through OAuth. Public repos, old contributions, work done under inaccessible accounts — these are real but can’t be fully verified.

The right approach isn’t to ignore unverified sources. It’s to discount them heavily and label them clearly. A user should always know what’s verified and what isn’t. A recruiter should always be able to see the difference at a glance.

Transparency about what can and can’t be verified is more credible than pretending everything is confirmed.

Gaming prevention is architectural, not cosmetic

If your verification system can be gamed by submitting famous repos you didn’t write, it’s not a verification system — it’s a vanity metric generator.

The aggregation rules matter as much as the scoring rules. How multiple sources combine, how unverified sources interact with verified ones, how the system handles edge cases — these decisions determine whether the final score means anything.

We’ve spent a lot of time on this. The details stay internal.

What this doesn’t solve

No verification system is perfect. Worth being honest about the limitations.

Commit squashing — some teams squash all PRs into single commits before merging. A developer who wrote 40 separate commits might appear as 1 in the contributor list.

Pair programming — code written together often gets committed under one person’s handle. The other person’s contribution is invisible to the API.

Private repos — everything above works for public repos. Private repos require broader OAuth scope, which is a bigger ask for users.

Old accounts — significant contributions under an account you no longer have access to can’t be verified without OAuth on that account.

These are real limitations. A verification badge isn’t a guarantee — it’s evidence. The weight of that evidence depends on the depth and breadth of verified sources.

Why this matters now

LinkedIn profiles are self-reported claims. AI writes perfect ones in 30 seconds. Endorsements come from people who’ve never seen your code. The entire professional identity system is built on statements that cost nothing to make and nothing to fabricate.

GitHub commits are different. A three-year commit history with consistent cadence, real collaborators, and downstream ecosystem impact — that can’t be generated by a chatbot. That’s real signal.

The question is how to surface that signal in a way that’s portable, shareable, and resistant to gaming. That’s the problem worth solving.

Where this is heading

I’ve been building this verification logic into a larger system called Warrant — a proof-of-work portfolio that computes verified scores from GitHub signals rather than letting engineers describe their own skills.

The exact methodology stays opaque — intentionally. The moment you publish the formula, people optimize for the formula instead of doing real work. We’d rather be the PageRank of professional identity than the ATS keyword game.

If you’re an engineer curious to see what your verified GitHub signals look like, you can try it at warrant-plum.vercel.app. Free, currently in beta, no credit card.

If you’ve thought hard about contribution verification — I’d genuinely like to hear what edge cases you ran into. The ones I listed above are the ones keeping me up at night.

How do you verify GitHub contributions without trusting self-reported skills?

I’ve been thinking about a problem that doesn’t get talked about enough in hiring: the gap between what someone claims about their work on linkedin and what they actually did.

Anyone can list “open source contributor” on their resume. Anyone can paste a GitHub repo URL in a portfolio. But without looking at the actual commit history and contributor data — you have no idea if that person wrote 80% of the codebase or merged one typo fix three years ago.

So I started building a system to verify this properly. Here’s what I learned — without giving away the methodology we use, because honestly, the moment you publish your exact algorithm, people optimize for it rather than actually doing the work.

The naive approach fails immediately

The first instinct is to just check if the person’s GitHub handle appears in the contributor list. Simple, right?

Not quite. Three problems come up immediately.

People have multiple GitHub accounts. Work account, personal account, old account from college. A developer might have significant contributions spread across two or three handles. Checking one handle misses the full picture.

Contribution depth varies wildly. Being listed as a contributor could mean 2,000 commits or 1 commit. The contributor list alone doesn’t tell you which. You need actual commit counts per author to understand the depth of contribution.

Public repos can be submitted by anyone. I can submit any famous open source repo to a portfolio system and imply I contributed to it. Without verifying my actual handle against the contributor data, the system has no way to know if I wrote the core architecture or just starred the repo.

What actually works — the principles

I’m not going to share the exact scoring formula. But I can share the principles that make verification meaningful.

Verify account ownership first

Before you can verify contributions, you need to verify identity. The only reliable way to confirm someone owns a GitHub account is OAuth. When someone authenticates via GitHub OAuth, you get a cryptographic proof of ownership — not a claim.

This is the identity anchor. Every contribution check runs against verified handles only. No claims accepted.

Handle the multi-account reality honestly

Developers legitimately use multiple GitHub accounts. A good verification system needs to support this — each additional account verified through its own OAuth flow.

The critical constraint: one GitHub account should only be linkable to one professional identity. Otherwise the whole system can be gamed by linking someone else’s high-signal account to your profile.

This requires exclusive handle claiming. First claim wins. If a handle is already associated with another profile — it’s blocked. No exceptions.

Contribution depth matters more than presence

There’s a meaningful difference between someone who authored 40% of a codebase and someone who fixed a typo. Both show up in the contributor list. Only one actually shaped the project.

The verification system needs to reflect this distinction. Not all verified contributions are equal. Depth matters. History matters. Consistency over time matters more than a spike of activity.

Unverified doesn’t mean worthless — but it means discounted

Not everything can be verified through OAuth. Public repos, old contributions, work done under inaccessible accounts — these are real but can’t be fully verified.

The right approach isn’t to ignore unverified sources. It’s to discount them heavily and label them clearly. A user should always know what’s verified and what isn’t. A recruiter should always be able to see the difference at a glance.

Transparency about what can and can’t be verified is more credible than pretending everything is confirmed.

Gaming prevention is architectural, not cosmetic

If your verification system can be gamed by submitting famous repos you didn’t write, it’s not a verification system — it’s a vanity metric generator.

The aggregation rules matter as much as the scoring rules. How multiple sources combine, how unverified sources interact with verified ones, how the system handles edge cases — these decisions determine whether the final score means anything.

We’ve spent a lot of time on this. The details stay internal.

What this doesn’t solve

No verification system is perfect. Worth being honest about the limitations.

Commit squashing — some teams squash all PRs into single commits before merging. A developer who wrote 40 separate commits might appear as 1 in the contributor list.

Pair programming — code written together often gets committed under one person’s handle. The other person’s contribution is invisible to the API.

Private repos — everything above works for public repos. Private repos require broader OAuth scope, which is a bigger ask for users.

Old accounts — significant contributions under an account you no longer have access to can’t be verified without OAuth on that account.

These are real limitations. A verification badge isn’t a guarantee — it’s evidence. The weight of that evidence depends on the depth and breadth of verified sources.

Why this matters now

LinkedIn profiles are self-reported claims. AI writes perfect ones in 30 seconds. Endorsements come from people who’ve never seen your code. The entire professional identity system is built on statements that cost nothing to make and nothing to fabricate.

GitHub commits are different. A three-year commit history with consistent cadence, real collaborators, and downstream ecosystem impact — that can’t be generated by a chatbot. That’s real signal.

The question is how to surface that signal in a way that’s portable, shareable, and resistant to gaming. That’s the problem worth solving.

Where this is heading

I’ve been building this verification logic into a larger system called Warrant — a proof-of-work portfolio that computes verified scores from GitHub signals rather than letting engineers describe their own skills.

The exact methodology stays opaque — intentionally. The moment you publish the formula, people optimize for the formula instead of doing real work. We’d rather be the PageRank of professional identity than the ATS keyword game.

If you’re an engineer curious to see what your verified GitHub signals look like, you can try it at warrant-plum.vercel.app. Free, currently in beta, no credit card.

If you’ve thought hard about contribution verification — I’d genuinely like to hear what edge cases you ran into. The ones I listed above are the ones keeping me up at night.

Building an MCP server so Claude can query my SaaS analytics directly

Last week I shipped a Model Context Protocol (MCP) server for my analytics SaaS. Now Claude Desktop, Cursor, and any MCP compatible client can query traffic, revenue, and funnel data directly.

This is a walkthrough of how I built it, what worked, and a couple of patterns that surprised me.

What MCP is, briefly

MCP is a protocol that lets AI clients invoke tools and read resources from external servers. Think of it as REST for LLM tool calling, with a stable schema and discovery.

Server skeleton

import { Server } from '@modelcontextprotocol/sdk/server/index.js'
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'

const server = new Server({
  name: 'zenovay',
  version: '1.0.0',
}, {
  capabilities: {
    tools: {},
    resources: {}
  }
})

Defining tools

server.setRequestHandler('tools/list', async () => ({
  tools: [
    {
      name: 'get_traffic',
      description: 'Get pageview and visitor counts for a site over a date range',
      inputSchema: {
        type: 'object',
        properties: {
          site: { type: 'string' },
          from: { type: 'string' },
          to: { type: 'string' }
        },
        required: ['site', 'from', 'to']
      }
    }
  ]
}))

The pattern that surprised me: structured returns

Way better than raw JSON: return a short natural language summary plus the data. Claude uses the summary for its response and the JSON for follow up questions.

What I did not expect

Users started asking Claude to do things I had not built dashboards for:

  • “Compare my paid traffic conversion rate this week vs last week”
  • “Which 5 pages had the biggest week over week drop in pageviews”
  • “Summarize what changed in my funnel completion rate over the last 30 days”

Claude does this by chaining multiple tool calls. I did not need to build any of those views. The tools are atomic, Claude composes.

This is the part I think is genuinely new about MCP. The interface is the LLM, the backend is just well shaped tools.

Install

npm install -g @zenovay/mcp then add to your Claude Desktop config.

Site: zenovay.com

Open source MCP server work happening here too? Curious what patterns others have found.

Valerio

How do you verify GitHub contributions without trusting self-reported skills?

I’ve been thinking about a problem that doesn’t get talked about enough in hiring: the gap between what someone claims about their work on linkedin and what they actually did.

Anyone can list “open source contributor” on their resume. Anyone can paste a GitHub repo URL in a portfolio. But without looking at the actual commit history and contributor data — you have no idea if that person wrote 80% of the codebase or merged one typo fix three years ago.

So I started building a system to verify this properly. Here’s what I learned — without giving away the methodology we use, because honestly, the moment you publish your exact algorithm, people optimize for it rather than actually doing the work.

The naive approach fails immediately

The first instinct is to just check if the person’s GitHub handle appears in the contributor list. Simple, right?

Not quite. Three problems come up immediately.

People have multiple GitHub accounts. Work account, personal account, old account from college. A developer might have significant contributions spread across two or three handles. Checking one handle misses the full picture.

Contribution depth varies wildly. Being listed as a contributor could mean 2,000 commits or 1 commit. The contributor list alone doesn’t tell you which. You need actual commit counts per author to understand the depth of contribution.

Public repos can be submitted by anyone. I can submit any famous open source repo to a portfolio system and imply I contributed to it. Without verifying my actual handle against the contributor data, the system has no way to know if I wrote the core architecture or just starred the repo.

What actually works — the principles

I’m not going to share the exact scoring formula. But I can share the principles that make verification meaningful.

Verify account ownership first

Before you can verify contributions, you need to verify identity. The only reliable way to confirm someone owns a GitHub account is OAuth. When someone authenticates via GitHub OAuth, you get a cryptographic proof of ownership — not a claim.

This is the identity anchor. Every contribution check runs against verified handles only. No claims accepted.

Handle the multi-account reality honestly

Developers legitimately use multiple GitHub accounts. A good verification system needs to support this — each additional account verified through its own OAuth flow.

The critical constraint: one GitHub account should only be linkable to one professional identity. Otherwise the whole system can be gamed by linking someone else’s high-signal account to your profile.

This requires exclusive handle claiming. First claim wins. If a handle is already associated with another profile — it’s blocked. No exceptions.

Contribution depth matters more than presence

There’s a meaningful difference between someone who authored 40% of a codebase and someone who fixed a typo. Both show up in the contributor list. Only one actually shaped the project.

The verification system needs to reflect this distinction. Not all verified contributions are equal. Depth matters. History matters. Consistency over time matters more than a spike of activity.

Unverified doesn’t mean worthless — but it means discounted

Not everything can be verified through OAuth. Public repos, old contributions, work done under inaccessible accounts — these are real but can’t be fully verified.

The right approach isn’t to ignore unverified sources. It’s to discount them heavily and label them clearly. A user should always know what’s verified and what isn’t. A recruiter should always be able to see the difference at a glance.

Transparency about what can and can’t be verified is more credible than pretending everything is confirmed.

Gaming prevention is architectural, not cosmetic

If your verification system can be gamed by submitting famous repos you didn’t write, it’s not a verification system — it’s a vanity metric generator.

The aggregation rules matter as much as the scoring rules. How multiple sources combine, how unverified sources interact with verified ones, how the system handles edge cases — these decisions determine whether the final score means anything.

We’ve spent a lot of time on this. The details stay internal.

What this doesn’t solve

No verification system is perfect. Worth being honest about the limitations.

Commit squashing — some teams squash all PRs into single commits before merging. A developer who wrote 40 separate commits might appear as 1 in the contributor list.

Pair programming — code written together often gets committed under one person’s handle. The other person’s contribution is invisible to the API.

Private repos — everything above works for public repos. Private repos require broader OAuth scope, which is a bigger ask for users.

Old accounts — significant contributions under an account you no longer have access to can’t be verified without OAuth on that account.

These are real limitations. A verification badge isn’t a guarantee — it’s evidence. The weight of that evidence depends on the depth and breadth of verified sources.

Why this matters now

LinkedIn profiles are self-reported claims. AI writes perfect ones in 30 seconds. Endorsements come from people who’ve never seen your code. The entire professional identity system is built on statements that cost nothing to make and nothing to fabricate.

GitHub commits are different. A three-year commit history with consistent cadence, real collaborators, and downstream ecosystem impact — that can’t be generated by a chatbot. That’s real signal.

The question is how to surface that signal in a way that’s portable, shareable, and resistant to gaming. That’s the problem worth solving.

Where this is heading

I’ve been building this verification logic into a larger system called Warrant — a proof-of-work portfolio that computes verified scores from GitHub signals rather than letting engineers describe their own skills.

The exact methodology stays opaque — intentionally. The moment you publish the formula, people optimize for the formula instead of doing real work. We’d rather be the PageRank of professional identity than the ATS keyword game.

If you’re an engineer curious to see what your verified GitHub signals look like, you can try it at warrant-plum.vercel.app. Free, currently in beta, no credit card.

If you’ve thought hard about contribution verification — I’d genuinely like to hear what edge cases you ran into. The ones I listed above are the ones keeping me up at night.

Google I/O 2026 and the Rise of the AI Ecosystem

Google I/O 2026: The Year AI Became Truly Developer-First

Every year, Google I/O gives us a glimpse into where technology is heading. But this year felt different.

Google I/O 2026 wasn’t just about flashy demos or incremental updates — it felt like a major shift toward making AI genuinely usable for developers, creators, and everyday builders. From Gemini integrations to Firebase AI tooling and Flutter improvements, the announcements painted a clear picture: Google wants AI to become part of every workflow, not just a standalone feature.

After following the keynotes and diving into the sessions, one theme stood out to me:

The barrier between an idea and a working product is shrinking faster than ever.

And honestly, that’s both exciting and a little overwhelming.

The Biggest Takeaway: AI Is Becoming Infrastructure

The most impressive part of this year’s announcements wasn’t a single model or product release. It was how deeply AI is now integrated into Google’s ecosystem.

During the Google Keynote and the “What’s New in Google AI” session, it became obvious that Google is no longer treating AI as an experiment. AI is now infrastructure.

Instead of asking developers to “add AI,” Google is embedding intelligence directly into:

  • Android development
  • Search experiences
  • Firebase workflows
  • Cloud tooling
  • Flutter applications
  • Productivity tools

That changes how we think about software development entirely.

We’re moving from:

  • Writing every feature manually

To:

  • Orchestrating systems that can reason, generate, and adapt.

Firebase + AI Was the Most Practical Announcement

Out of everything announced, the Firebase updates were probably the most exciting for me as a developer.

Not because they were flashy.

Because they were immediately useful.

The new AI-powered Firebase workflows seem focused on solving real development bottlenecks:

  • Faster backend setup
  • Smarter debugging
  • Automated app flows
  • Better AI integrations without huge infrastructure complexity

For indie developers and small teams, this matters a lot.

One of the hardest parts of building modern applications is no longer just coding — it’s managing scale, integrations, authentication, analytics, AI APIs, deployment pipelines, and user experience all at once.

Firebase is evolving into something much bigger than a backend service.

It’s becoming an AI-assisted development platform.

And that’s a huge shift.

Flutter Quietly Had One of the Best Sessions

The “What’s New in Flutter” session didn’t generate the same hype as the AI announcements, but I think it deserves more attention.

Flutter continues to mature into one of the most efficient cross-platform frameworks available today. What stood out this year was Google’s focus on:

  • Performance improvements
  • Better tooling
  • Faster iteration cycles
  • Stronger AI-assisted workflows for UI development

The interesting part is how AI and Flutter now complement each other.

AI can accelerate:

  • UI generation
  • Component scaffolding
  • Documentation
  • Testing
  • State management suggestions

But Flutter still gives developers control over the final experience.

That balance matters.

A lot of AI-generated software today still feels generic. Flutter remains one of the best tools for developers who want productivity without sacrificing creativity.

AI Coding Assistants Are Entering a New Phase

Another thing I noticed across multiple sessions was the evolution of AI coding tools.

Last year, AI assistants mostly helped autocomplete code.

This year, the focus shifted toward:

  • Multi-step reasoning
  • Context-aware workflows
  • Architecture suggestions
  • End-to-end development assistance

That’s a massive leap.

We’re quickly approaching a world where developers spend less time writing boilerplate and more time:

  • Designing systems
  • Reviewing logic
  • Shaping product experiences
  • Making architectural decisions

Ironically, AI may make human creativity even more valuable.

Because when everyone can generate code quickly, the real differentiator becomes:

  • Product thinking
  • User empathy
  • Taste
  • Problem selection

The Most Underrated Shift: Developer Accessibility

One thing I think people are underestimating is how much easier entry into software development is becoming.

A few years ago, building an AI-powered application required:

  • ML expertise
  • Infrastructure knowledge
  • GPU access
  • Large engineering budgets

Now?
A solo developer can prototype surprisingly advanced applications using Google’s ecosystem.

That democratization is probably more important than any single feature announcement.

The next generation of builders won’t need permission, massive teams, or huge funding rounds to create impactful products.

That changes innovation itself.

My Biggest Question After I/O 2026

As exciting as everything looks, I still have one major question:

How do we prevent AI-assisted development from making software feel identical?

When tools generate interfaces, code structures, and workflows automatically, there’s a risk that creativity becomes standardized.

The challenge for developers moving forward won’t just be learning AI tools.

It’ll be learning how to use them without losing originality.

The best developers in the AI era may not be the people who automate everything.

They may be the people who know where human judgment still matters most.

Final Thoughts

Google I/O 2026 felt less like a product showcase and more like a preview of a new development era.

The biggest innovation wasn’t one model, framework, or API.

It was the growing idea that software creation itself is changing.

Developers are transitioning from:

  • Writing every system manually

To:

  • Collaborating with intelligent tools.

And while the technology is impressive, the real opportunity lies in what people choose to build with it.

That’s the part I’m most excited about.

Because the future of development won’t belong to AI alone.

It’ll belong to developers who learn how to work alongside it creatively.

Google I/O 2026 and the Rise of the AI Ecosystem

Google I/O 2026: The Year AI Became Truly Developer-First

Every year, Google I/O gives us a glimpse into where technology is heading. But this year felt different.

Google I/O 2026 wasn’t just about flashy demos or incremental updates — it felt like a major shift toward making AI genuinely usable for developers, creators, and everyday builders. From Gemini integrations to Firebase AI tooling and Flutter improvements, the announcements painted a clear picture: Google wants AI to become part of every workflow, not just a standalone feature.

After following the keynotes and diving into the sessions, one theme stood out to me:

The barrier between an idea and a working product is shrinking faster than ever.

And honestly, that’s both exciting and a little overwhelming.

The Biggest Takeaway: AI Is Becoming Infrastructure

The most impressive part of this year’s announcements wasn’t a single model or product release. It was how deeply AI is now integrated into Google’s ecosystem.

During the Google Keynote and the “What’s New in Google AI” session, it became obvious that Google is no longer treating AI as an experiment. AI is now infrastructure.

Instead of asking developers to “add AI,” Google is embedding intelligence directly into:

  • Android development
  • Search experiences
  • Firebase workflows
  • Cloud tooling
  • Flutter applications
  • Productivity tools

That changes how we think about software development entirely.

We’re moving from:

  • Writing every feature manually

To:

  • Orchestrating systems that can reason, generate, and adapt.

Firebase + AI Was the Most Practical Announcement

Out of everything announced, the Firebase updates were probably the most exciting for me as a developer.

Not because they were flashy.

Because they were immediately useful.

The new AI-powered Firebase workflows seem focused on solving real development bottlenecks:

  • Faster backend setup
  • Smarter debugging
  • Automated app flows
  • Better AI integrations without huge infrastructure complexity

For indie developers and small teams, this matters a lot.

One of the hardest parts of building modern applications is no longer just coding — it’s managing scale, integrations, authentication, analytics, AI APIs, deployment pipelines, and user experience all at once.

Firebase is evolving into something much bigger than a backend service.

It’s becoming an AI-assisted development platform.

And that’s a huge shift.

Flutter Quietly Had One of the Best Sessions

The “What’s New in Flutter” session didn’t generate the same hype as the AI announcements, but I think it deserves more attention.

Flutter continues to mature into one of the most efficient cross-platform frameworks available today. What stood out this year was Google’s focus on:

  • Performance improvements
  • Better tooling
  • Faster iteration cycles
  • Stronger AI-assisted workflows for UI development

The interesting part is how AI and Flutter now complement each other.

AI can accelerate:

  • UI generation
  • Component scaffolding
  • Documentation
  • Testing
  • State management suggestions

But Flutter still gives developers control over the final experience.

That balance matters.

A lot of AI-generated software today still feels generic. Flutter remains one of the best tools for developers who want productivity without sacrificing creativity.

AI Coding Assistants Are Entering a New Phase

Another thing I noticed across multiple sessions was the evolution of AI coding tools.

Last year, AI assistants mostly helped autocomplete code.

This year, the focus shifted toward:

  • Multi-step reasoning
  • Context-aware workflows
  • Architecture suggestions
  • End-to-end development assistance

That’s a massive leap.

We’re quickly approaching a world where developers spend less time writing boilerplate and more time:

  • Designing systems
  • Reviewing logic
  • Shaping product experiences
  • Making architectural decisions

Ironically, AI may make human creativity even more valuable.

Because when everyone can generate code quickly, the real differentiator becomes:

  • Product thinking
  • User empathy
  • Taste
  • Problem selection

The Most Underrated Shift: Developer Accessibility

One thing I think people are underestimating is how much easier entry into software development is becoming.

A few years ago, building an AI-powered application required:

  • ML expertise
  • Infrastructure knowledge
  • GPU access
  • Large engineering budgets

Now?
A solo developer can prototype surprisingly advanced applications using Google’s ecosystem.

That democratization is probably more important than any single feature announcement.

The next generation of builders won’t need permission, massive teams, or huge funding rounds to create impactful products.

That changes innovation itself.

My Biggest Question After I/O 2026

As exciting as everything looks, I still have one major question:

How do we prevent AI-assisted development from making software feel identical?

When tools generate interfaces, code structures, and workflows automatically, there’s a risk that creativity becomes standardized.

The challenge for developers moving forward won’t just be learning AI tools.

It’ll be learning how to use them without losing originality.

The best developers in the AI era may not be the people who automate everything.

They may be the people who know where human judgment still matters most.

Final Thoughts

Google I/O 2026 felt less like a product showcase and more like a preview of a new development era.

The biggest innovation wasn’t one model, framework, or API.

It was the growing idea that software creation itself is changing.

Developers are transitioning from:

  • Writing every system manually

To:

  • Collaborating with intelligent tools.

And while the technology is impressive, the real opportunity lies in what people choose to build with it.

That’s the part I’m most excited about.

Because the future of development won’t belong to AI alone.

It’ll belong to developers who learn how to work alongside it creatively.

CV vs Resume: What’s the Difference and Which Do You Need?

CV or resume? It seems like it should be a simple question. It’s not — at least not without knowing where you’re applying, what industry you’re in, and what the person reading your document is expecting.

The confusion is compounded by the fact that the terms are used interchangeably in everyday conversation, even by hiring managers who should know better. Send the wrong document and you’ll either hand a recruiter forty pages they never asked for, or walk into an academic job search with a one-page summary that tells the hiring committee almost nothing.

This guide cuts through the terminology and tells you exactly what each document is, when to use each one, and how the geography of job searching changes the calculus entirely.

The Core Difference: Purpose and Length

Let’s start with definitions that actually hold up.

A resume is a brief, targeted document — typically one to two pages — summarizing your most relevant professional experience, skills, and achievements for a specific role. It’s selective by design. You don’t include everything; you include the most relevant things. The goal is to make an immediate impression on a recruiter who’s spending seconds on an initial scan.

A CV (curriculum vitae, Latin for “course of life”) is a comprehensive document that records your complete professional, academic, and intellectual history. It grows as you accumulate experience, publications, presentations, grants, certifications, affiliations, and accomplishments. There is no length limit — a senior academic’s CV might run fifteen to thirty pages, and that length is appropriate and expected.

The fundamental difference is not just length. It’s philosophy. A resume is a curated marketing document. A CV is a comprehensive record. Both have legitimate uses; they just serve different purposes for different audiences.

CV vs Resume: Side-by-Side Comparison

CV Resume
Length No limit — grows over career (2 to 30+ pages) 1–2 pages, hard cap
Purpose Complete professional and academic record Targeted pitch for a specific role
When to update Every time you add a credential, publication, or role Each time you apply — tailored per job
Customization Minimal — it’s a record, not a pitch High — must be tailored to the job description
Common in Academia, research, medicine; UK/Australia/NZ for commercial roles US, Canada commercial roles; increasingly global
Key sections Education, publications, grants, teaching, conferences, affiliations Work experience, skills, achievements, summary
Typical audience Hiring committees, grant reviewers, academic institutions Recruiters, HR, hiring managers in commercial orgs

The table above reflects the strict definitions. In practice, as the geography section below covers, the term “CV” gets used for what is functionally a resume in many English-speaking markets.

When to Use a Resume

In most commercial job markets — corporate roles, startups, tech companies, marketing agencies, sales organizations, financial services firms, consulting practices — a resume is what’s expected. The recruiter has 200 applications in a queue, a six-second initial screen, and no interest in reading your complete educational history.

A resume should be:

  • One to two pages. One page is often sufficient for early-career professionals (under five years of experience). Two pages is appropriate for mid-career professionals. More than two pages for a commercial role is almost always a problem, not a demonstration of experience.

  • Targeted to the role. This is the defining feature of a strong resume. You’re not listing everything you’ve done — you’re listing what’s most relevant to this specific job posting.

  • Achievement-oriented. Bullets in a resume should describe outcomes and impact, not just responsibilities. “Managed a team” is a responsibility. “Led a team of 7 engineers to deliver a platform migration 3 weeks ahead of schedule, reducing hosting costs by $40K annually” is an achievement.

  • ATS-compatible. If you’re applying through an online portal, your resume will likely be parsed by an Applicant Tracking System before a human sees it. This means clean formatting, standard section headers, and language that mirrors the job description.

If you’re in the United States, Canada, or the UK applying for non-academic, non-medical, non-research roles, use a resume. Full stop.

NextCV — your premium CV, tailored to every job request

When to Use a CV

There are two main contexts where a CV is the correct document.

Academic, research, and scientific roles. If you’re applying for a faculty position, a postdoctoral fellowship, a research grant, or any role within a university or research institution, you need a CV. The academic CV is a complete record of your scholarly work: education, dissertation, publications, conference presentations, grants awarded, teaching experience, committee service, professional affiliations, and more. Academic hiring committees want the full picture, and they’ll read it. A one-page resume in this context would be taken as a misunderstanding of the role, the field, or both.

Certain medical and clinical roles. In many countries, medical hiring — especially for hospital positions, fellowships, and specialized clinical roles — uses a CV format rather than a resume. This is particularly true in the UK, Ireland, Australia, and New Zealand, where the term “CV” is used more broadly, and in academic medical centers anywhere.

Non-academic CV users also include: scientists applying for industry research positions (especially in pharma and biotech), professionals applying to EU institutions or some government positions that request a Europass CV or a long-form document, and international applicants following the conventions of their home country.

Freelancers and consultants sometimes use an extended CV format for project-based work where a complete record of engagements and outputs demonstrates breadth and depth — though a well-structured resume or portfolio can often serve this purpose better.

What Employers Actually See

The format debate is real, but hiring managers and recruiters are mostly focused on something simpler: does this document tell me quickly whether this person can do this job?

When you send the wrong document type, you create friction before anyone has read a word. An academic hiring committee receiving a one-page resume will either assume you don’t understand academic hiring, or assume your record is thin. A commercial recruiter receiving a twelve-page academic CV will either not read it, or mentally flag you as someone who doesn’t understand how corporate hiring works. Neither impression recovers easily.

ATS systems don’t care what you call it, but they do care about structure. Most ATS platforms parse both CVs and resumes the same way — extracting text, matching keywords, scoring against job requirements. Where problems arise is formatting: tables, graphics, headers embedded in text boxes, and multi-column layouts confuse parsers. Whether you’re submitting a CV or a resume, a clean single-column layout with standard section labels (Work Experience, Education, Skills) will outperform a visually complex document every time.

What hiring managers actually prioritize — once a document clears the ATS — is relevance and clarity. Not whether you called it a CV or a resume. Not whether the formatting is clever. Whether the first fifteen seconds of reading give them a clear answer to: “Is this person qualified for this role, and can I see evidence of it?” Structure and specificity answer that question. Generic descriptions and paragraph-length bullet points do not.

The single biggest formatting mistake in this context is treating your document as a job description listing rather than an evidence file. Recruiters are pattern-matching for impact and fit. Give them the pattern they’re looking for.

The Geography Problem

Here’s where it gets genuinely confusing: in much of the world, “CV” simply means the document you submit when applying for a job — regardless of length or format. And what that document looks like varies dramatically by country.

United States: The distinction is clearest here. “Resume” is the standard commercial job application document (1–2 pages). “CV” refers to the long-form academic or research document. If an American company says “send us your CV,” they almost certainly mean your resume.

United Kingdom, Ireland, Australia, New Zealand: “CV” is the standard term for what Americans call a resume. When a British company posts a job and asks for your CV, they want a 1–2 page targeted document, not your complete academic history. “Resume” is rarely used as a term in these markets, though the documents are functionally equivalent.

Continental Europe: Practice varies by country. Germany has traditionally used a fairly structured CV format with a photo and personal details that would be unusual in an Anglo-American application. France has historically included a photo and date of birth. The Europass CV format, promoted by the EU, is a standardized long-form template used for applications across EU institutions and in some member state public sectors. Increasingly, professional CVs in major European markets are converging toward the cleaner, more targeted Anglo-American format for commercial roles.

Canada: Follows American conventions. Resume for commercial roles; CV for academic and research positions.

Scandinavia: CV is the standard term. Commercial CVs are typically concise (1–2 pages), clean in design, and often include a professional photo and brief personal statement — though the photo convention is less universal than it once was.

The practical implication: before you apply, look at the conventions for the country where the company is based. If you’re applying to a UK company, send what they call a CV (which is your resume). If you’re applying to a US university for a faculty position, send an academic CV. If you’re applying to a German company, check whether their hiring norms include a photo and personal details section.

The Photo Question

Including a photo on your CV or resume is one of the most geographically variable norms in job searching.

Never include a photo if you’re applying to US, Canadian, or UK companies for commercial roles. In these markets, photos are explicitly discouraged to reduce unconscious bias in screening. Many applicant tracking systems are designed to strip them. Some recruiters will discard applications with photos on the assumption that the applicant doesn’t understand local norms.

Commonly expected in Germany, Austria, Switzerland, parts of Scandinavia, and several other European and Asian markets. If local norms include a photo and you omit it, your application may look incomplete or unfamiliar to the recruiter.

Optional or transitional in France, Spain, and many other markets where the convention is shifting.

When in doubt, check the job posting. Companies with international hiring experience often specify their preferences. LinkedIn also publishes country-specific application guides. And if the company has a careers page with example materials, those are worth reviewing.

Content Differences Beyond Length

Beyond length and the photo question, there are content conventions that differ between resume and CV formats.

Personal details. Academic CVs typically include your institutional affiliation and academic email. Commercial CVs in some countries include date of birth, nationality, or marital status — none of which appear in American or British commercial resumes (and which should not appear: this information is legally protected in many jurisdictions, and including it puts the reviewer in an awkward position).

References. Commercial resumes typically note “references available upon request” or omit the topic entirely. Academic CVs often include actual names and contact information for references, since committees may contact them early in the process.

Objective statement vs. professional summary. Old-style commercial resumes used objective statements (“Seeking a challenging role in marketing”). Modern commercial resumes use professional summaries — a 2–4 sentence statement of who you are professionally and what you bring to the role. Academic CVs typically omit both, since your record speaks for itself.

Publications and presentations. On a commercial resume, these appear only if directly relevant (e.g., industry publications for a thought leadership role). On an academic CV, they get their own sections and are listed comprehensively in standard citation format.

Three steps to a tailored CV

Common Mistakes

Most CV and resume errors fall into a small number of recurring patterns. These are the ones that actually cost people interviews.

1. Sending an academic CV for a commercial role. This happens more often than it should, particularly with candidates transitioning from academia to industry. A twelve-page document listing every conference paper and committee role is not what a tech company’s HR manager wants to read. Condense it: lead with transferable skills, highlight industry-relevant achievements, and cut everything that doesn’t speak to the commercial role.

2. Not tailoring the document to the job description. A generic resume sent to fifty companies is less effective than five tailored resumes sent to five companies. Every job description contains the keywords the ATS is scanning for and the priorities the hiring manager cares about. Mirror that language. Reorder your bullets to lead with the most relevant experience. This isn’t gaming the system — it’s communicating clearly.

3. Including outdated or irrelevant experience. The job you had in 2003 that isn’t related to anything you’re applying for now should not appear on your resume. For most professionals, ten to fifteen years of experience is the relevant window. Earlier roles can be listed as a one-line entry (company, title, dates) or omitted entirely. Every line you include is a line the reader has to process — make sure it’s earning its place.

4. Ignoring country-specific conventions. Including a photo on an application to a US company, or omitting one on an application to a German company, signals unfamiliarity with local norms. Same with including date of birth or marital status where they’re not expected, or using a two-page academic CV format for a commercial role in a market that expects one page.

5. Including a photo where it’s inappropriate. This gets its own entry because the consequences are real. In the US, UK, and Canada, an application photo can trigger unconscious bias and is sometimes used as a reason to disqualify an application outright — not by principled decision, but by the recruiter who assumes the applicant doesn’t know the rules. When in doubt, leave it out.

6. Listing responsibilities instead of achievements. “Responsible for managing social media accounts” tells a hiring manager almost nothing. “Grew organic Instagram reach by 340% over eight months through a weekly video series” tells them what you actually did and what it produced. The switch from responsibility to outcome is the single highest-leverage edit you can make to any resume or CV.

Making the Decision

The decision tree is actually fairly simple once you have the context:

Are you applying to an academic, research, or medical role? → CV (long-form, comprehensive).

Are you applying to a commercial role in the US or Canada? → Resume (1–2 pages, targeted).

Are you applying to a commercial role in the UK, Ireland, Australia, or New Zealand? → CV (but in practice, this is a resume — 1–2 pages, targeted — just called a CV locally).

Are you applying in continental Europe? → Check country conventions. For most professional commercial roles, a clean 1–2 page document is appropriate; be attentive to local norms around photos and personal details.

Are you unsure? → A clean, well-formatted, targeted 1–2 page document is the safest default for any commercial role in most English-speaking markets.

One Document, Multiple Versions

The practical reality for most active job seekers is that you need the same information formatted for different contexts. The content of what you’ve done doesn’t change — your job is to understand how to present it appropriately for the market you’re applying to and the role you’re targeting.

Tools like NextCV are useful precisely here: you maintain a complete profile of your experience, and you generate tailored versions for each application. The underlying content is the same; what changes is the emphasis, the language, and the level of detail that’s appropriate for each context.

Whether you call it a CV or a resume, the goal is the same: give the person reading it exactly what they need to make a confident decision about inviting you to interview. The format is just the packaging.

Frequently Asked Questions

What is the difference between a CV and a resume?

A CV (curriculum vitae) is a comprehensive, long-form record of your complete professional and academic history — there’s no length limit, and it grows throughout your career. A resume is a short, targeted document (typically 1–2 pages) summarizing your most relevant experience for a specific role. The core difference is philosophy: a CV is a complete record; a resume is a curated pitch.

Is a CV the same as a resume?

In strict usage, no — they serve different purposes and have different lengths. In practice, many countries (particularly the UK, Australia, Ireland, and New Zealand) use the term “CV” to refer to what Americans call a resume: a short, targeted job application document. So the same 1–2 page document might be called a CV in London and a resume in New York, even though they’re functionally identical.

Should I use a CV or resume for UK jobs?

Use what UK employers call a CV — which is functionally a resume: 1–2 pages, targeted to the role, achievement-oriented. UK employers asking for a “CV” do not want a long-form academic document. The format is the same as an American resume; only the label differs.

Should I use a CV or resume in the USA?

Use a resume for commercial roles in the US: 1–2 pages, tailored to the specific job posting. In the US, “CV” refers specifically to the long-form academic or research document. If you’re applying for a faculty position, fellowship, or research grant at a US institution, then a CV is correct. For everything else — corporate, startup, nonprofit, government — use a resume.

How long should a CV be?

It depends on context. An academic or research CV has no length limit and should include everything relevant to your scholarly record — senior academics commonly have 15–30 page CVs. A commercial CV (what the UK and Australia call the document used for job applications) should be 1–2 pages, the same as an American resume. If someone asks “how long should my CV be” for a job in industry, the answer is almost always: two pages maximum.

Can I use a resume instead of a CV?

Yes, in most commercial job markets. If you’re applying to corporate, tech, startup, finance, or any non-academic commercial role — in the US, Canada, UK, Australia, or most of Europe — a well-structured 1–2 page document works regardless of what you call it. The only context where substituting a resume for a CV is genuinely problematic is academic and research hiring, where committees expect the full comprehensive record and will notice its absence.

Ready to put this into practice? Build your job application CV with NextCV →

Related Articles

CV vs Resume: What’s the Difference and Which Do You Need?

CV or resume? It seems like it should be a simple question. It’s not — at least not without knowing where you’re applying, what industry you’re in, and what the person reading your document is expecting.

The confusion is compounded by the fact that the terms are used interchangeably in everyday conversation, even by hiring managers who should know better. Send the wrong document and you’ll either hand a recruiter forty pages they never asked for, or walk into an academic job search with a one-page summary that tells the hiring committee almost nothing.

This guide cuts through the terminology and tells you exactly what each document is, when to use each one, and how the geography of job searching changes the calculus entirely.

The Core Difference: Purpose and Length

Let’s start with definitions that actually hold up.

A resume is a brief, targeted document — typically one to two pages — summarizing your most relevant professional experience, skills, and achievements for a specific role. It’s selective by design. You don’t include everything; you include the most relevant things. The goal is to make an immediate impression on a recruiter who’s spending seconds on an initial scan.

A CV (curriculum vitae, Latin for “course of life”) is a comprehensive document that records your complete professional, academic, and intellectual history. It grows as you accumulate experience, publications, presentations, grants, certifications, affiliations, and accomplishments. There is no length limit — a senior academic’s CV might run fifteen to thirty pages, and that length is appropriate and expected.

The fundamental difference is not just length. It’s philosophy. A resume is a curated marketing document. A CV is a comprehensive record. Both have legitimate uses; they just serve different purposes for different audiences.

CV vs Resume: Side-by-Side Comparison

CV Resume
Length No limit — grows over career (2 to 30+ pages) 1–2 pages, hard cap
Purpose Complete professional and academic record Targeted pitch for a specific role
When to update Every time you add a credential, publication, or role Each time you apply — tailored per job
Customization Minimal — it’s a record, not a pitch High — must be tailored to the job description
Common in Academia, research, medicine; UK/Australia/NZ for commercial roles US, Canada commercial roles; increasingly global
Key sections Education, publications, grants, teaching, conferences, affiliations Work experience, skills, achievements, summary
Typical audience Hiring committees, grant reviewers, academic institutions Recruiters, HR, hiring managers in commercial orgs

The table above reflects the strict definitions. In practice, as the geography section below covers, the term “CV” gets used for what is functionally a resume in many English-speaking markets.

When to Use a Resume

In most commercial job markets — corporate roles, startups, tech companies, marketing agencies, sales organizations, financial services firms, consulting practices — a resume is what’s expected. The recruiter has 200 applications in a queue, a six-second initial screen, and no interest in reading your complete educational history.

A resume should be:

  • One to two pages. One page is often sufficient for early-career professionals (under five years of experience). Two pages is appropriate for mid-career professionals. More than two pages for a commercial role is almost always a problem, not a demonstration of experience.

  • Targeted to the role. This is the defining feature of a strong resume. You’re not listing everything you’ve done — you’re listing what’s most relevant to this specific job posting.

  • Achievement-oriented. Bullets in a resume should describe outcomes and impact, not just responsibilities. “Managed a team” is a responsibility. “Led a team of 7 engineers to deliver a platform migration 3 weeks ahead of schedule, reducing hosting costs by $40K annually” is an achievement.

  • ATS-compatible. If you’re applying through an online portal, your resume will likely be parsed by an Applicant Tracking System before a human sees it. This means clean formatting, standard section headers, and language that mirrors the job description.

If you’re in the United States, Canada, or the UK applying for non-academic, non-medical, non-research roles, use a resume. Full stop.

NextCV — your premium CV, tailored to every job request

When to Use a CV

There are two main contexts where a CV is the correct document.

Academic, research, and scientific roles. If you’re applying for a faculty position, a postdoctoral fellowship, a research grant, or any role within a university or research institution, you need a CV. The academic CV is a complete record of your scholarly work: education, dissertation, publications, conference presentations, grants awarded, teaching experience, committee service, professional affiliations, and more. Academic hiring committees want the full picture, and they’ll read it. A one-page resume in this context would be taken as a misunderstanding of the role, the field, or both.

Certain medical and clinical roles. In many countries, medical hiring — especially for hospital positions, fellowships, and specialized clinical roles — uses a CV format rather than a resume. This is particularly true in the UK, Ireland, Australia, and New Zealand, where the term “CV” is used more broadly, and in academic medical centers anywhere.

Non-academic CV users also include: scientists applying for industry research positions (especially in pharma and biotech), professionals applying to EU institutions or some government positions that request a Europass CV or a long-form document, and international applicants following the conventions of their home country.

Freelancers and consultants sometimes use an extended CV format for project-based work where a complete record of engagements and outputs demonstrates breadth and depth — though a well-structured resume or portfolio can often serve this purpose better.

What Employers Actually See

The format debate is real, but hiring managers and recruiters are mostly focused on something simpler: does this document tell me quickly whether this person can do this job?

When you send the wrong document type, you create friction before anyone has read a word. An academic hiring committee receiving a one-page resume will either assume you don’t understand academic hiring, or assume your record is thin. A commercial recruiter receiving a twelve-page academic CV will either not read it, or mentally flag you as someone who doesn’t understand how corporate hiring works. Neither impression recovers easily.

ATS systems don’t care what you call it, but they do care about structure. Most ATS platforms parse both CVs and resumes the same way — extracting text, matching keywords, scoring against job requirements. Where problems arise is formatting: tables, graphics, headers embedded in text boxes, and multi-column layouts confuse parsers. Whether you’re submitting a CV or a resume, a clean single-column layout with standard section labels (Work Experience, Education, Skills) will outperform a visually complex document every time.

What hiring managers actually prioritize — once a document clears the ATS — is relevance and clarity. Not whether you called it a CV or a resume. Not whether the formatting is clever. Whether the first fifteen seconds of reading give them a clear answer to: “Is this person qualified for this role, and can I see evidence of it?” Structure and specificity answer that question. Generic descriptions and paragraph-length bullet points do not.

The single biggest formatting mistake in this context is treating your document as a job description listing rather than an evidence file. Recruiters are pattern-matching for impact and fit. Give them the pattern they’re looking for.

The Geography Problem

Here’s where it gets genuinely confusing: in much of the world, “CV” simply means the document you submit when applying for a job — regardless of length or format. And what that document looks like varies dramatically by country.

United States: The distinction is clearest here. “Resume” is the standard commercial job application document (1–2 pages). “CV” refers to the long-form academic or research document. If an American company says “send us your CV,” they almost certainly mean your resume.

United Kingdom, Ireland, Australia, New Zealand: “CV” is the standard term for what Americans call a resume. When a British company posts a job and asks for your CV, they want a 1–2 page targeted document, not your complete academic history. “Resume” is rarely used as a term in these markets, though the documents are functionally equivalent.

Continental Europe: Practice varies by country. Germany has traditionally used a fairly structured CV format with a photo and personal details that would be unusual in an Anglo-American application. France has historically included a photo and date of birth. The Europass CV format, promoted by the EU, is a standardized long-form template used for applications across EU institutions and in some member state public sectors. Increasingly, professional CVs in major European markets are converging toward the cleaner, more targeted Anglo-American format for commercial roles.

Canada: Follows American conventions. Resume for commercial roles; CV for academic and research positions.

Scandinavia: CV is the standard term. Commercial CVs are typically concise (1–2 pages), clean in design, and often include a professional photo and brief personal statement — though the photo convention is less universal than it once was.

The practical implication: before you apply, look at the conventions for the country where the company is based. If you’re applying to a UK company, send what they call a CV (which is your resume). If you’re applying to a US university for a faculty position, send an academic CV. If you’re applying to a German company, check whether their hiring norms include a photo and personal details section.

The Photo Question

Including a photo on your CV or resume is one of the most geographically variable norms in job searching.

Never include a photo if you’re applying to US, Canadian, or UK companies for commercial roles. In these markets, photos are explicitly discouraged to reduce unconscious bias in screening. Many applicant tracking systems are designed to strip them. Some recruiters will discard applications with photos on the assumption that the applicant doesn’t understand local norms.

Commonly expected in Germany, Austria, Switzerland, parts of Scandinavia, and several other European and Asian markets. If local norms include a photo and you omit it, your application may look incomplete or unfamiliar to the recruiter.

Optional or transitional in France, Spain, and many other markets where the convention is shifting.

When in doubt, check the job posting. Companies with international hiring experience often specify their preferences. LinkedIn also publishes country-specific application guides. And if the company has a careers page with example materials, those are worth reviewing.

Content Differences Beyond Length

Beyond length and the photo question, there are content conventions that differ between resume and CV formats.

Personal details. Academic CVs typically include your institutional affiliation and academic email. Commercial CVs in some countries include date of birth, nationality, or marital status — none of which appear in American or British commercial resumes (and which should not appear: this information is legally protected in many jurisdictions, and including it puts the reviewer in an awkward position).

References. Commercial resumes typically note “references available upon request” or omit the topic entirely. Academic CVs often include actual names and contact information for references, since committees may contact them early in the process.

Objective statement vs. professional summary. Old-style commercial resumes used objective statements (“Seeking a challenging role in marketing”). Modern commercial resumes use professional summaries — a 2–4 sentence statement of who you are professionally and what you bring to the role. Academic CVs typically omit both, since your record speaks for itself.

Publications and presentations. On a commercial resume, these appear only if directly relevant (e.g., industry publications for a thought leadership role). On an academic CV, they get their own sections and are listed comprehensively in standard citation format.

Three steps to a tailored CV

Common Mistakes

Most CV and resume errors fall into a small number of recurring patterns. These are the ones that actually cost people interviews.

1. Sending an academic CV for a commercial role. This happens more often than it should, particularly with candidates transitioning from academia to industry. A twelve-page document listing every conference paper and committee role is not what a tech company’s HR manager wants to read. Condense it: lead with transferable skills, highlight industry-relevant achievements, and cut everything that doesn’t speak to the commercial role.

2. Not tailoring the document to the job description. A generic resume sent to fifty companies is less effective than five tailored resumes sent to five companies. Every job description contains the keywords the ATS is scanning for and the priorities the hiring manager cares about. Mirror that language. Reorder your bullets to lead with the most relevant experience. This isn’t gaming the system — it’s communicating clearly.

3. Including outdated or irrelevant experience. The job you had in 2003 that isn’t related to anything you’re applying for now should not appear on your resume. For most professionals, ten to fifteen years of experience is the relevant window. Earlier roles can be listed as a one-line entry (company, title, dates) or omitted entirely. Every line you include is a line the reader has to process — make sure it’s earning its place.

4. Ignoring country-specific conventions. Including a photo on an application to a US company, or omitting one on an application to a German company, signals unfamiliarity with local norms. Same with including date of birth or marital status where they’re not expected, or using a two-page academic CV format for a commercial role in a market that expects one page.

5. Including a photo where it’s inappropriate. This gets its own entry because the consequences are real. In the US, UK, and Canada, an application photo can trigger unconscious bias and is sometimes used as a reason to disqualify an application outright — not by principled decision, but by the recruiter who assumes the applicant doesn’t know the rules. When in doubt, leave it out.

6. Listing responsibilities instead of achievements. “Responsible for managing social media accounts” tells a hiring manager almost nothing. “Grew organic Instagram reach by 340% over eight months through a weekly video series” tells them what you actually did and what it produced. The switch from responsibility to outcome is the single highest-leverage edit you can make to any resume or CV.

Making the Decision

The decision tree is actually fairly simple once you have the context:

Are you applying to an academic, research, or medical role? → CV (long-form, comprehensive).

Are you applying to a commercial role in the US or Canada? → Resume (1–2 pages, targeted).

Are you applying to a commercial role in the UK, Ireland, Australia, or New Zealand? → CV (but in practice, this is a resume — 1–2 pages, targeted — just called a CV locally).

Are you applying in continental Europe? → Check country conventions. For most professional commercial roles, a clean 1–2 page document is appropriate; be attentive to local norms around photos and personal details.

Are you unsure? → A clean, well-formatted, targeted 1–2 page document is the safest default for any commercial role in most English-speaking markets.

One Document, Multiple Versions

The practical reality for most active job seekers is that you need the same information formatted for different contexts. The content of what you’ve done doesn’t change — your job is to understand how to present it appropriately for the market you’re applying to and the role you’re targeting.

Tools like NextCV are useful precisely here: you maintain a complete profile of your experience, and you generate tailored versions for each application. The underlying content is the same; what changes is the emphasis, the language, and the level of detail that’s appropriate for each context.

Whether you call it a CV or a resume, the goal is the same: give the person reading it exactly what they need to make a confident decision about inviting you to interview. The format is just the packaging.

Frequently Asked Questions

What is the difference between a CV and a resume?

A CV (curriculum vitae) is a comprehensive, long-form record of your complete professional and academic history — there’s no length limit, and it grows throughout your career. A resume is a short, targeted document (typically 1–2 pages) summarizing your most relevant experience for a specific role. The core difference is philosophy: a CV is a complete record; a resume is a curated pitch.

Is a CV the same as a resume?

In strict usage, no — they serve different purposes and have different lengths. In practice, many countries (particularly the UK, Australia, Ireland, and New Zealand) use the term “CV” to refer to what Americans call a resume: a short, targeted job application document. So the same 1–2 page document might be called a CV in London and a resume in New York, even though they’re functionally identical.

Should I use a CV or resume for UK jobs?

Use what UK employers call a CV — which is functionally a resume: 1–2 pages, targeted to the role, achievement-oriented. UK employers asking for a “CV” do not want a long-form academic document. The format is the same as an American resume; only the label differs.

Should I use a CV or resume in the USA?

Use a resume for commercial roles in the US: 1–2 pages, tailored to the specific job posting. In the US, “CV” refers specifically to the long-form academic or research document. If you’re applying for a faculty position, fellowship, or research grant at a US institution, then a CV is correct. For everything else — corporate, startup, nonprofit, government — use a resume.

How long should a CV be?

It depends on context. An academic or research CV has no length limit and should include everything relevant to your scholarly record — senior academics commonly have 15–30 page CVs. A commercial CV (what the UK and Australia call the document used for job applications) should be 1–2 pages, the same as an American resume. If someone asks “how long should my CV be” for a job in industry, the answer is almost always: two pages maximum.

Can I use a resume instead of a CV?

Yes, in most commercial job markets. If you’re applying to corporate, tech, startup, finance, or any non-academic commercial role — in the US, Canada, UK, Australia, or most of Europe — a well-structured 1–2 page document works regardless of what you call it. The only context where substituting a resume for a CV is genuinely problematic is academic and research hiring, where committees expect the full comprehensive record and will notice its absence.

Ready to put this into practice? Build your job application CV with NextCV →

Related Articles

How do you verify GitHub contributions without trusting self-reported skills?

I’ve been thinking about a problem that doesn’t get talked about enough in hiring: the gap between what someone claims about their work on linkedin and what they actually did.

Anyone can list “open source contributor” on their resume. Anyone can paste a GitHub repo URL in a portfolio. But without looking at the actual commit history and contributor data — you have no idea if that person wrote 80% of the codebase or merged one typo fix three years ago.

So I started building a system to verify this properly. Here’s what I learned — without giving away the methodology we use, because honestly, the moment you publish your exact algorithm, people optimize for it rather than actually doing the work.

The naive approach fails immediately

The first instinct is to just check if the person’s GitHub handle appears in the contributor list. Simple, right?

Not quite. Three problems come up immediately.

People have multiple GitHub accounts. Work account, personal account, old account from college. A developer might have significant contributions spread across two or three handles. Checking one handle misses the full picture.

Contribution depth varies wildly. Being listed as a contributor could mean 2,000 commits or 1 commit. The contributor list alone doesn’t tell you which. You need actual commit counts per author to understand the depth of contribution.

Public repos can be submitted by anyone. I can submit any famous open source repo to a portfolio system and imply I contributed to it. Without verifying my actual handle against the contributor data, the system has no way to know if I wrote the core architecture or just starred the repo.

What actually works — the principles

I’m not going to share the exact scoring formula. But I can share the principles that make verification meaningful.

Verify account ownership first

Before you can verify contributions, you need to verify identity. The only reliable way to confirm someone owns a GitHub account is OAuth. When someone authenticates via GitHub OAuth, you get a cryptographic proof of ownership — not a claim.

This is the identity anchor. Every contribution check runs against verified handles only. No claims accepted.

Handle the multi-account reality honestly

Developers legitimately use multiple GitHub accounts. A good verification system needs to support this — each additional account verified through its own OAuth flow.

The critical constraint: one GitHub account should only be linkable to one professional identity. Otherwise the whole system can be gamed by linking someone else’s high-signal account to your profile.

This requires exclusive handle claiming. First claim wins. If a handle is already associated with another profile — it’s blocked. No exceptions.

Contribution depth matters more than presence

There’s a meaningful difference between someone who authored 40% of a codebase and someone who fixed a typo. Both show up in the contributor list. Only one actually shaped the project.

The verification system needs to reflect this distinction. Not all verified contributions are equal. Depth matters. History matters. Consistency over time matters more than a spike of activity.

Unverified doesn’t mean worthless — but it means discounted

Not everything can be verified through OAuth. Public repos, old contributions, work done under inaccessible accounts — these are real but can’t be fully verified.

The right approach isn’t to ignore unverified sources. It’s to discount them heavily and label them clearly. A user should always know what’s verified and what isn’t. A recruiter should always be able to see the difference at a glance.

Transparency about what can and can’t be verified is more credible than pretending everything is confirmed.

Gaming prevention is architectural, not cosmetic

If your verification system can be gamed by submitting famous repos you didn’t write, it’s not a verification system — it’s a vanity metric generator.

The aggregation rules matter as much as the scoring rules. How multiple sources combine, how unverified sources interact with verified ones, how the system handles edge cases — these decisions determine whether the final score means anything.

We’ve spent a lot of time on this. The details stay internal.

What this doesn’t solve

No verification system is perfect. Worth being honest about the limitations.

Commit squashing — some teams squash all PRs into single commits before merging. A developer who wrote 40 separate commits might appear as 1 in the contributor list.

Pair programming — code written together often gets committed under one person’s handle. The other person’s contribution is invisible to the API.

Private repos — everything above works for public repos. Private repos require broader OAuth scope, which is a bigger ask for users.

Old accounts — significant contributions under an account you no longer have access to can’t be verified without OAuth on that account.

These are real limitations. A verification badge isn’t a guarantee — it’s evidence. The weight of that evidence depends on the depth and breadth of verified sources.

Why this matters now

LinkedIn profiles are self-reported claims. AI writes perfect ones in 30 seconds. Endorsements come from people who’ve never seen your code. The entire professional identity system is built on statements that cost nothing to make and nothing to fabricate.

GitHub commits are different. A three-year commit history with consistent cadence, real collaborators, and downstream ecosystem impact — that can’t be generated by a chatbot. That’s real signal.

The question is how to surface that signal in a way that’s portable, shareable, and resistant to gaming. That’s the problem worth solving.

Where this is heading

I’ve been building this verification logic into a larger system called Warrant — a proof-of-work portfolio that computes verified scores from GitHub signals rather than letting engineers describe their own skills.

The exact methodology stays opaque — intentionally. The moment you publish the formula, people optimize for the formula instead of doing real work. We’d rather be the PageRank of professional identity than the ATS keyword game.

If you’re an engineer curious to see what your verified GitHub signals look like, you can try it at warrant-plum.vercel.app. Free, currently in beta, no credit card.

If you’ve thought hard about contribution verification — I’d genuinely like to hear what edge cases you ran into. The ones I listed above are the ones keeping me up at night.

How do you verify GitHub contributions without trusting self-reported skills?

I’ve been thinking about a problem that doesn’t get talked about enough in hiring: the gap between what someone claims about their work on linkedin and what they actually did.

Anyone can list “open source contributor” on their resume. Anyone can paste a GitHub repo URL in a portfolio. But without looking at the actual commit history and contributor data — you have no idea if that person wrote 80% of the codebase or merged one typo fix three years ago.

So I started building a system to verify this properly. Here’s what I learned — without giving away the methodology we use, because honestly, the moment you publish your exact algorithm, people optimize for it rather than actually doing the work.

The naive approach fails immediately

The first instinct is to just check if the person’s GitHub handle appears in the contributor list. Simple, right?

Not quite. Three problems come up immediately.

People have multiple GitHub accounts. Work account, personal account, old account from college. A developer might have significant contributions spread across two or three handles. Checking one handle misses the full picture.

Contribution depth varies wildly. Being listed as a contributor could mean 2,000 commits or 1 commit. The contributor list alone doesn’t tell you which. You need actual commit counts per author to understand the depth of contribution.

Public repos can be submitted by anyone. I can submit any famous open source repo to a portfolio system and imply I contributed to it. Without verifying my actual handle against the contributor data, the system has no way to know if I wrote the core architecture or just starred the repo.

What actually works — the principles

I’m not going to share the exact scoring formula. But I can share the principles that make verification meaningful.

Verify account ownership first

Before you can verify contributions, you need to verify identity. The only reliable way to confirm someone owns a GitHub account is OAuth. When someone authenticates via GitHub OAuth, you get a cryptographic proof of ownership — not a claim.

This is the identity anchor. Every contribution check runs against verified handles only. No claims accepted.

Handle the multi-account reality honestly

Developers legitimately use multiple GitHub accounts. A good verification system needs to support this — each additional account verified through its own OAuth flow.

The critical constraint: one GitHub account should only be linkable to one professional identity. Otherwise the whole system can be gamed by linking someone else’s high-signal account to your profile.

This requires exclusive handle claiming. First claim wins. If a handle is already associated with another profile — it’s blocked. No exceptions.

Contribution depth matters more than presence

There’s a meaningful difference between someone who authored 40% of a codebase and someone who fixed a typo. Both show up in the contributor list. Only one actually shaped the project.

The verification system needs to reflect this distinction. Not all verified contributions are equal. Depth matters. History matters. Consistency over time matters more than a spike of activity.

Unverified doesn’t mean worthless — but it means discounted

Not everything can be verified through OAuth. Public repos, old contributions, work done under inaccessible accounts — these are real but can’t be fully verified.

The right approach isn’t to ignore unverified sources. It’s to discount them heavily and label them clearly. A user should always know what’s verified and what isn’t. A recruiter should always be able to see the difference at a glance.

Transparency about what can and can’t be verified is more credible than pretending everything is confirmed.

Gaming prevention is architectural, not cosmetic

If your verification system can be gamed by submitting famous repos you didn’t write, it’s not a verification system — it’s a vanity metric generator.

The aggregation rules matter as much as the scoring rules. How multiple sources combine, how unverified sources interact with verified ones, how the system handles edge cases — these decisions determine whether the final score means anything.

We’ve spent a lot of time on this. The details stay internal.

What this doesn’t solve

No verification system is perfect. Worth being honest about the limitations.

Commit squashing — some teams squash all PRs into single commits before merging. A developer who wrote 40 separate commits might appear as 1 in the contributor list.

Pair programming — code written together often gets committed under one person’s handle. The other person’s contribution is invisible to the API.

Private repos — everything above works for public repos. Private repos require broader OAuth scope, which is a bigger ask for users.

Old accounts — significant contributions under an account you no longer have access to can’t be verified without OAuth on that account.

These are real limitations. A verification badge isn’t a guarantee — it’s evidence. The weight of that evidence depends on the depth and breadth of verified sources.

Why this matters now

LinkedIn profiles are self-reported claims. AI writes perfect ones in 30 seconds. Endorsements come from people who’ve never seen your code. The entire professional identity system is built on statements that cost nothing to make and nothing to fabricate.

GitHub commits are different. A three-year commit history with consistent cadence, real collaborators, and downstream ecosystem impact — that can’t be generated by a chatbot. That’s real signal.

The question is how to surface that signal in a way that’s portable, shareable, and resistant to gaming. That’s the problem worth solving.

Where this is heading

I’ve been building this verification logic into a larger system called Warrant — a proof-of-work portfolio that computes verified scores from GitHub signals rather than letting engineers describe their own skills.

The exact methodology stays opaque — intentionally. The moment you publish the formula, people optimize for the formula instead of doing real work. We’d rather be the PageRank of professional identity than the ATS keyword game.

If you’re an engineer curious to see what your verified GitHub signals look like, you can try it at warrant-plum.vercel.app. Free, currently in beta, no credit card.

If you’ve thought hard about contribution verification — I’d genuinely like to hear what edge cases you ran into. The ones I listed above are the ones keeping me up at night.