The GTM Engineer Portfolio: What to Build Before You Apply Anywhere

Build six portfolio pieces that prove you can do GTM engineering, from a full market map to scored accounts, and show them as a repo, video and README.

These are the six pieces of work I’d want to see from anyone who applies for a GTM engineering role.

A GTM (go-to-market) engineer builds the lists, data and automated steps a sales and marketing team uses every day: lists of target companies, data about them, scoring, and the workflows that start outreach. Most of the job is code and checks, so a résumé says little about whether you can do it.

You build all six pieces for the market of one company you’d like to join, with Claude Code writing most of the code. Each piece reports its counts. You send the last one to that company before you apply.

This guide covers what to build for each piece, the prompt to start it, what “done” looks like, and how to present it so a hiring manager understands it in two minutes.

It’s for SDRs, RevOps (revenue operations) people, analysts and marketers who want to move into GTM engineering, and for anyone who already does the work but has no public proof of it.

Build the pieces in order. Pieces 2, 3 and 4 each use the output of the piece before, and piece 6 uses the scoring from piece 4. Piece 5 turns your notes into posts. Each piece ends with “How to show it”. The full README template is near the end.

What a hiring manager wants to find out

The job is building systems that run on their own. A list of tools on a résumé tells a hiring manager what you’ve used.

In my experience they’re trying to answer four questions. Each piece below answers at least one:

  • Judgment. What did you leave out, and why?
  • Checks. How do you know the output is right, and where could it break without anyone noticing?
  • Cost. What does one account on the list cost, and where did you pick a free source over a paid one?
  • Explaining. Could a sales leader read your README without calling you?

A repo can answer all four in the time it takes to scroll through it.

Set up before the first piece

You need four things, and none of them takes more than an hour:

  • Claude Code. It runs in the Terminal, the text window on your computer where you type commands. You describe what you want, and it writes and runs the code. Every piece below starts with a prompt you paste into it.
  • A GitHub account. A GitHub repo is a public folder for your code. A README is the page at the top of that folder that explains what the code does.
  • One people and company database with an API. An API lets your script ask a tool for data directly. Prospeo, BlitzAPI, GetLeads and Apollo are common picks. BlitzAPI and GetLeads are flat rate: one fixed price a month instead of a price per result. Prospeo and Apollo charge per credit, a prepaid unit, so you pay as you go.
  • An email verifier, like MillionVerifier. It asks a mail server whether a mailbox exists, without sending an email. It charges a fraction of a cent per check.

Your scripts log in to each tool with an API key, a password for software. Keep the keys in a file called .env and never upload it.

Pick one company and build everything for its market

Build every piece for the market of one company you’d like to work for. The pieces connect that way, and the last one becomes something you can hand to that company.

A good pick sells to companies you can find on the web, posts GTM roles on its careers page, and describes its ideal customer clearly on its homepage, case studies and sales job ads. That description is its ICP, the ideal customer profile. Write it down in three to five sentences. You turn it into rules for your build.

The example. Say you’re Noor, an SDR who wants a GTM engineering role. The company Noor would most like to join is Waybright. Waybright sells software that checks freight invoices for mid-size US third-party logistics providers (3PLs), the companies that store and ship goods for other businesses.

Here are the six pieces. In sales, an account is a company you want to sell to.

PieceInputOutputQuestion it answers
Market mapA market fileOne row per company, kept or excluded with a reasonJudgment, checks
Signal detectorThe map plus job adsAccounts that show the signal, with proofJudgment
Contact searchThose accountsEvery buyer, with a verified emailCost, checks
ScoringEvery column so farA tier per account, the same on every runChecks
Content systemYour build notesOne post per pieceExplaining
Sample for the companyAll of the aboveOne sheet, one emailAll four

1. Map every company in one market

What to build. A list of every company in one market, each one kept or excluded with a reason. This list is your TAM (total addressable market). My TAM playbook covers every step in depth. Here’s the short version.

Before you download anything, write a market file: the country, what the companies do, the size range and one yes/no question every company has to pass. For Waybright: US companies with 50 to 1,000 employees, and the question “Does this company store or ship goods for other businesses?”

Then download every company that could fit from your database, remove duplicates by website domain, and let an AI model answer the question for every company from its website. Before that full run, label 30 companies by hand and fix the prompt until it agrees with you.

Your first search only finds companies with the industry labels you picked. So run a lookalike search, a search that returns companies similar to the ones you kept, check the new ones with the same question, and repeat until a round adds less than 3% new companies that pass.

Keep a notes file from day one. Write down each problem, what it cost and how you fixed it. Piece 5 turns these notes into posts.

Paste this into Claude Code to start:

Read market.yaml and the API docs at <link to the docs>.
Build tools/pull_companies.py: one search per industry label and size
range, filtered to the US. Save every API response unchanged to raw/.
Skip pages already on disk, so a crash can restart where it stopped.
Before the run, print the number of searches and the expected credits
and wait for my yes. Then build tools/dedupe.py (one row per website
domain) and tools/judge.py, which sends each company's website text
to the model with the question from market.yaml and saves the answer,
the sentence behind it and a reason for every "no".

Done means:

  • A market file with the country, size range, question and the companies that look right but aren’t, saved before the first download
  • The raw data saved as files, so a failed download can restart where it stopped
  • One row per company after removing duplicates, and a reason on every excluded row
  • Lookalike rounds until a round adds less than 3% new companies
  • Ten rows checked by hand against the company’s website. Fix the rule that let a wrong row through, then pick ten new rows. Stop after three rounds of ten in a row come back clean.

Say Noor has 6,800 companies after removing duplicates. 2,400 pass the question and the size range, and 4,400 are excluded, each with a reason. Two lookalike rounds add 210 and then 50 companies that pass. 50 is under 3% of the list, so Noor stops at 2,660.

Check the count against a public number. The Census counts 4,236 US warehouses with 50 to 999 employees (2023). One 3PL often runs several warehouses, so 2,660 companies is plausible. A count of 10,000 would mean the question let in the wrong companies.

How to show it. Put the counts at the top of the README. Add the market file, the excluded reasons and your three clean rounds below. Mark which steps cost money and which used free sources.

2. Build a detector for one buying signal

What to build. A script that checks every company on your list for one signal. A signal is an event that suggests a company may need you now. Each account that shows it gets a link to the proof, the date and the sentence that proves it.

For Waybright, the signal is a 3PL hiring people to check or pay freight bills, because Waybright’s software does that work automatically.

The source is job ads. TheirStack and LeadMagic have job-data APIs. Apify, a marketplace for scrapers (tools that copy data from websites into a table), has scrapers for job boards. Some companies post jobs only on their own website, so have a script search each careers page for the same keywords.

A keyword match doesn’t prove a need. “Freight billing” also appears in company descriptions, in benefits sections and in ads for drivers. So an AI model reads each ad and answers one question, and your code checks the answer.

Build tools/signal.py. For every domain in market.csv, collect job ads
from the last 30 days that contain "freight bill", "freight audit" or
"freight payment", from <job data API> and from the company's careers
page. Send each ad to the model with this question: "Is this job mainly
about checking or paying freight bills? Answer yes or no, and quote the
sentence that shows it." Keep a yes only if the quote appears word for
word in the ad. Save domain, ad link, post date, answer and quote. On
the next run, print only what's new since the last run.

Done means:

  • One signal, written as one sentence with a time window, for example “a 3PL on the list posted a freight billing or audit job in the last 30 days”
  • A proof link, a date and the quote on every account that shows the signal
  • 20 matching and 20 non-matching ads checked by hand, with every miss written down
  • A weekly run that lists only what’s new since the last run

Say the job sources return 1,400 ads from the last 30 days that mention freight billing at companies on Noor’s list. The model confirms 310 as real billing or audit jobs. Some companies posted more than one, so the 310 jobs belong to 180 companies.

How to show it. Show one row where the keyword matched and the model said no, with the reason next to it. That row shows why the model step is there.

3. Find every buyer at each account

What to build. For each of these accounts, every person Waybright’s sales team would want to reach, each with a checked email address.

Write the buying titles down before you search: controller (the head of accounting), CFO (chief financial officer), VP of finance and freight audit manager. These people own the bills Waybright checks. Pull every person with one of these titles at every account, never only one person per account.

Start with a flat-rate database like GetLeads or BlitzAPI, and use Prospeo last, because you pay per contact there. Before you look up a single email, remove Waybright’s existing customers. They’re on its website as logos and case studies.

For the emails, most companies build addresses the same way. For John Smith at company.com, it’s usually john.smith@, john@ or jsmith@.

Build these three, check them in that order with the verifier, and keep the first valid one. Pay an email finder like Prospeo or LeadMagic only for the people none of the three works for.

Build tools/contacts.py. For every domain in signal.csv, search
<people API> for these titles: Controller, CFO, VP of Finance, Freight
Audit Manager. Keep every match, no limit per company. Remove domains
listed in customers.csv. Remove duplicate people. For each person,
build first.last@, first@ and flast@ on the company domain and check
them in that order with MillionVerifier. Keep the first "ok". Write
everyone else to finder_queue.csv. Print people found, emails valid and
cost per valid email.

Done means:

  • Each person appears once before any paid lookup, so you never pay twice for one email
  • A source column on every row: which tool found it, on which date
  • Only “valid” addresses go on the list. Drop every “unknown”, because the verifier couldn’t confirm the mailbox.
  • Catch-all addresses (the mail server accepts every address, so a normal check can’t confirm them) used only after a tool built for this, like LeadMagic or BounceBan, clears them
  • The cost per verified contact, calculated from your own run
  • Ten rows checked against a live source, like the company’s team page or the person’s LinkedIn profile

Say the search finds 410 people at 150 of the 180 accounts. 290 of them end up with a valid email, at 128 accounts.

How to show it. A table in the README: accounts in, accounts with a buyer, people found, valid emails, cost per valid email.

4. Score every account with fixed rules

What to build. A score that gives the same result every time it runs on the same data. An AI model can help you write the rules once. After that, a short Python script applies them, and no AI model makes decisions while the script runs.

Each fact you score becomes a column: billing job posted, days since the post, company size, number of verified buyers.

Every account gets points, and the points decide its tier: A, B or C, where A fits best. The points and the minimum score for each tier are stored in one YAML file, a simple text format for settings. One script reads it.

Write rules.yaml from these notes: <your notes on what makes a good
Waybright account>. One rule per column in accounts.csv, each with
points and a one-line reason. Tier A from <x> points, B from <y>.
Then build tools/score.py: it reads rules.yaml and accounts.csv, adds
the points, writes the tier and the reasons into every row, and uses
no AI model. Run it twice and print the sha256 hash of both outputs.

Done means:

  • Rules in one file that someone who doesn’t code can read
  • Two runs on the same data give the same output. The README shows the hash of both outputs. A hash is a short code calculated from a file’s content, and identical files always get the same hash.
  • A reason on every row, like “+30 billing job 12 days ago, +20 size 200 to 500, +15 verified controller”
  • The count per tier, and ten rows read by hand until three rounds in a row come back clean
  • No column that is true for almost every row, because it gives everyone the same points and changes no tier

Say the 180 accounts come out as 40 in tier A, 85 in tier B and 55 in tier C.

How to show it. Record your screen while you run the script twice. End the video on the comparison that shows no difference.

5. Turn every finished piece into a post

Posts show that you can explain a system to people who never open the repo.

What to build. A small setup that turns each finished piece into a LinkedIn post.

Read posts/my_style/ (10 posts or messages I wrote myself) and
notes.md (my build notes for <piece>). Draft one LinkedIn post about
this piece in my style: the problem, the count from my run, one thing
that broke and how I fixed it. If the notes have no real count or no
fix, write "nothing to post" instead of a draft.

Done means:

  • One post per finished piece, drafted from your build notes
  • You read every draft and post only the ones with a real count from your own run and one problem you fixed
  • Every post links to the repo

How to show it. Link the posts in the main README. Posting while you build also means your work has readers before you apply.

6. Send a sample to the company before you apply

What to build. Take tier A from the scoring and send it to the person at Waybright who would be your manager, usually the head of RevOps or growth. Send a shared sheet with the accounts, the signal, the proof and the verified buyers, plus a tab that explains how you built it.

Done means:

  • Only tier A accounts with a verified buyer. In the example, 36 of the 40 tier A accounts have one.
  • A “How this was built” tab that links to the repo
  • Every proof link opened again the day before you send
  • One email to one person, written and sent by hand
Subject: 36 US 3PLs hiring freight billing staff right now

Hi {first_name},

I built a list of the US 3PL market as a practice project and found 36
mid-size 3PLs that posted freight billing roles in the last 30 days.
Each row has the ad, the date and a verified finance contact. The
second tab shows how the list was built.

{sheet_link}

Use it however you like.
{your_name}

Don’t mention the job in this email. I think the sheet makes a better impression on its own. Apply a few days later and mention the sheet in the first line of your application.

How to show it. The last section of the README says what you sent and to which role, without naming the company. The sheet itself stays private.

Show it as a repo, a video and a one-page README

Plan for a hiring manager who looks at your work for two minutes and then decides whether to look closer.

Repo. One folder per piece and a main README that links them in order. Add sample data: 20 rows you write yourself, with no real people in them. Upload a copy of .env called .env.example with the key names and no values. Git, the tool behind GitHub, keeps every old version of your files, so check that no real names, emails or keys were ever uploaded.

Video. One Loom (a short screen recording) per piece, under five minutes, recorded on the sample data:

0:00  The problem in one sentence, and the market
0:30  The result: the counts on screen
1:00  Run it live on the sample data
2:30  One row where a check caught something, and the fix
3:30  Cost per row, and what stays manual
4:15  What you'd build next

README. One page with the same shape for every piece, so a reader learns it once:

# [Piece]: [what it does, for which market, in one line]

## Result
[The counts, e.g. 6,800 companies: 2,400 kept, 4,400 excluded, +260 from lookalikes]
[Video link]

## In and out
In:  [file or source]
Out: [file and its columns]

## How it works
[3 to 6 numbered steps, one script each]

## Checks
[What runs automatically, what you check by hand, what failed and how you fixed it]

## Cost
[Cost per account from your run, which steps are free]

## What stays manual, and why
## What I'd build next
## Run it
[One command, on the sample data]

Fit it into six weeks while you work full time

This is my estimate for evenings and one weekend day a week.

  • Weeks 1 and 2: the market map. Set up the content system in the same weeks.
  • Week 3: the signal detector
  • Week 4: the contact search
  • Week 5: scoring
  • Week 6: the sheet, a last check and the email, then the application a few days later

One post goes out for every finished piece. By week 6, five posts describe the same work as the repo.

Avoid these seven mistakes in your portfolio

  • Real people’s data in a public repo. Upload code, counts and sample rows without real people. Share real output privately, and read your data provider’s terms before you share any of it.
  • Keys in the history. Before your first upload (a commit), add .env to a file called .gitignore. Git never uploads the files listed there. If a key was ever uploaded, delete it in that tool and create a new one.
  • A tool’s own tutorial data. A demo on a tool’s sample table only shows you can follow a tutorial. Build on a market you picked.
  • A table with no counts. Without the counts per step, nobody can tell whether rows went missing.
  • Mass emails to show it works. The sample goes to one person. Hundreds of cold emails (emails to strangers) from a new domain can get it blocked by email providers and annoy the market you want to work in.
  • Results you can’t prove. A claimed number of meetings with no data behind it reads as invented. Counts from your own run are enough.
  • More tools than you need. Every extra tool is something the company would have to pay for. Use the cheapest path that passes the checks, and say in the README why you chose it.

Where to start today

You can start your portfolio today in three steps:

  1. Pick the company and read its homepage, its case studies and three of its sales job ads.
  2. Write the market file for its market: the country, the size range, the yes/no question and the companies that look right but aren’t.
  3. Map every company in that market with the prompt from piece 1 and put the counts at the top of your README.

Blog

Keep Reading

Start With a System Check

Start with a free target market map or a short system check. Either way, you leave with something useful.