Stage 12: Public GTM Teardowns and Portfolio

The short answer

A teardown is a written, evidence-backed analysis of how one company sells: its pricing page, signup, onboarding, credits and upgrade path. A GTM engineer who publishes teardowns shows what a resume cannot: how they reason about a go-to-market system, with the data attached. This stage gives you a repeatable method, a way to capture dated evidence, the few pricing-psychology results that survive scrutiny, and a portfolio repo that holds your teardowns next to the eleven projects you built in this course.

Why this matters

A resume says you know SQL. A teardown says you read a pricing page, found the metric behind it, and can defend the conclusion. A portfolio is the cheapest way to show both skill and judgment.

The roadmap this course grew from says: "GTM leaders and Revenue Architects are hired for their strategic judgment, not just their SQL skills." Test that against real postings. On October 7, 2026 I pulled every open role from five public job boards through their public APIs: Anthropic (Greenhouse), OpenAI, Clay, Ramp and Cursor (Ashby). Greenhouse and Ashby are applicant tracking systems (ATS), the software many firms use to post jobs and take applications. The code is in the project below.

• The sample is small. 1,809 open roles. 55 have "GTM", "go-to-market" or "revenue operations" in the title, and 20 of those have builder titles (engineer, analytics, data, systems). Five companies are a snapshot, not the market.
• No "Revenue Architect". No title combined "architect" with GTM, revenue, sales or growth. Only Clay posted "GTM Engineer" titles (two). Its seven other "GTME" titles are sales and enablement roles. I infer that GTME names the customer group Clay sells to.
• Judgment appears next to engineering. OpenAI's "Software Engineer, GTM Growth Engineering" asks for "4+ years of experience as a software, product, or full-stack engineer" and "strong product judgment". Ramp's "GTM Business Systems Engineer, Quote-to-Cash" posting pairs systems design with "strong commercial judgment". The same Ramp posting (quote-to-cash is the flow from a sales quote to a paid invoice) asks for "7+ years building applications on the Salesforce Platform" and owning "data contracts, idempotency, error handling, reconciliation". Idempotency means doing an operation twice gives the same result as doing it once. Cursor's "GTM Applications Engineer" wants "production full-stack products ... not just scripts or dashboards".

Verdict: half right. "Not just SQL" holds: these postings ask for production software skills. "Hired for strategy" overstates it: in this sample, judgment is asked for in addition to engineering, never instead of it. Show both.

Core concepts

What a teardown is

A teardown answers one question about one company with evidence a reader can check. "How does Cursor price agent usage?" is a teardown question. "Cursor pricing is smart" is an opinion. Every teardown has four parts: a claim in one sentence, dated evidence, your reasoning, and the limits.

The teardown template

Run the same seven steps every time, so teardowns are comparable and you get faster.

Steps 3 and 4 need an account of your own. Never create fake accounts or work around a block.

Pricing psychology: what the evidence supports

Most posts on this topic repeat lab results as laws. Treat each effect as a hypothesis to test.

Anchoring. A number you see first pulls later estimates toward it. Tversky and Kahneman (1974) list "adjustment from an anchor" as one of three judgment heuristics. On a pricing page the top plan may anchor the middle one. That is a mechanism, not a measured effect.

The decoy effect. Adding a clearly worse option can raise the share of the option it resembles. Huber, Payne and Puto (1982) showed this with asymmetrically dominated alternatives. The famous example is in Dan Ariely's Predictably Irrational (2008): an Economist ad with web-only at $59, print-only at $125 and print plus web at $125. In the book's classroom test, 84% of 100 MIT students chose print plus web with the print-only decoy present. Without it, 68% chose web-only and 32% the bundle. I found these numbers in secondary summaries and could not check them against a paper, so treat them as one reported experiment.

The effect is weaker outside the lab. Frederick, Lee and Baskin (2014) argue it "may be restricted to stylized product representations in which every product dimension is represented by a number". Yang and Lynn (2014) report "Ninety-one attempts to produce an attraction effect ... produced only 11 reliable effects". A pricing page with plan names, feature lists and screenshots is closer to the realistic case, so never write "the decoy effect explains this tier" without a test.

The compromise effect. Simonson and Tversky (1992) propose "extremeness aversion": an option gains appeal when it is the middle one in the set. That is the logic of good-better-best ladders (three plans, with the middle one meant to look like the sensible pick). It is lab evidence too, so say "consistent with", not "caused by".

Charm pricing. Ending a price in 9 has field evidence. Anderson and Simester (2003) ran three experiments and report that "use of a $9 price ending increased demand in all three", with a stronger effect for new items. They tested retail items, not software subscriptions. Now look at the data below: none of the headline prices I read from the five vendors ends in 9 ($17, $20, $25, $60, $100, $200). I have not verified any study of charm endings on developer-tool subscriptions, so treat it as an open question.

A worked teardown: five AI vendors, October 7, 2026

I read each page on October 7, 2026. The table says where I could not read a number.

A post in OpenAI's community forum, dated April 9, 2026, announces a $100 per month Pro tier. A reply in the same thread quotes a $200 Pro tier. That is a user's quote, not an OpenAI page, so treat the current Pro price as unconfirmed.

Three patterns show up. Each is a possible claim.

1. The entry paid plan sits at $20 to $25. Claude Pro, Cursor Pro and Replit Core list $20. Lovable Pro lists $25. Above that the ladder is steep: Claude Max starts at 5x the price of Pro, and Cursor's docs list $60 and $200.
2. The page steers to the middle. Cursor's pricing FAQ says "We recommend Pro+ for daily agent users, and Ultra for agent power users", and its docs say daily Agent users typically use "$60-$100/mo total usage". Clay marks its middle plan, Growth, "Recommended". This fits the compromise effect and also plain usage-matching. The page cannot tell you which.
3. The same credit costs more on a higher plan. Lovable's FAQ says "credits are not necessarily equal in value across different plans". At the entry level, Pro is $0.25 per credit ($25 / 100) and Business is $0.50 ($50 / 100). Its docs price top-ups the same way: $15 per 50 credits on Pro, $30 per 50 on Business. My reading is that the extra money buys Business features, not credits.

A claim from pattern 2: "Cursor's pricing page leads with $20, but its own FAQ recommends the $60 Pro+ plan to daily agent users." The evidence is two dated quotes: the FAQ line, and the docs table that prices Pro+ at $60. The limit: you do not know conversion by tier.

Credits and limits side by side

Credits are where AI pricing differs most from classic SaaS. A value metric is the unit a vendor bills, chosen so the bill grows as the customer gets more value. Classic SaaS bills per seat (per user). These vendors bill per time window, per credit, or per dollar of usage. Stage 5 covers how to build one. Compare the unit and what happens at the limit, using each vendor's own pages from October 7, 2026.

The OpenAI API sells one model at several speeds. For gpt-6-astra, per million input and output tokens (prompts up to 272K tokens), the page lists Standard at $10 and $50, Batch and Flex at $5 and $25, Fast at $20 and $100, and Ultrafast at $60 and $300. Speed is the priced variable: from half price to six times the price.

Capturing evidence

A pricing page you remember is not evidence. Save three things on the day: a full-page screenshot, the page text, and an independent copy. The Wayback Machine gives you the independent copy and the history.

• History. The CDX server lists captures of a URL. collapse=timestamp:6 keeps the first capture of each month. A replay URL with id_ after the timestamp returns the original bytes with no toolbar.
• Gotchas I hit today. Save Page Now answered 429 Too Many Requests when I called it quickly. Replays came back gzip-compressed, so a script that decodes them as text reads garbage. Back off, and decompress.
• Blocks. Replit's page returned "Sorry, you have been blocked" to my headless browser, and ChatGPT's returned empty text. Do not try to evade this. Take a screenshot by hand in your normal browser and record that you did.

Here is real output from the history script below. For Cursor, the first monthly capture containing $200 is 2025-07-29, and the first containing $60 is 2025-09-22. Through the 2026-06-01 capture the raw HTML shows $60 and $200 beside $20 and $40. From 2026-07-01 on, it shows only $20 and $40, while the docs today still list $60 and $200.

The wrong conclusion is "Cursor removed two tiers in July 2026". A likely reading is that the Pro, Pro+, Ultra selector now keeps those prices out of the static HTML, but I did not confirm it. Only a screenshot settles it, which is why the template saves both.

Reading a benchmark

A benchmark is a median or percentile from a sample. Before you use one, ask who is in the sample, how the metric is defined, and whether the sample leans toward survivors or one audience.

Two retention metrics appear below. Gross revenue retention (GRR) is the share of starting recurring revenue you keep, ignoring expansion. Net revenue retention (NRR) adds expansion back. Example: you start the year with $100 of monthly recurring revenue. Customers worth $20 cancel, and others upgrade by $10. GRR is 80% ($80 / $100) and NRR is 90% ($90 / $100). ARR is annual recurring revenue. R^2 is a number from 0 to 1 that says how closely points follow a trend line.

A defensible claim: "Entry plans at $20 to $25 sit in the under-$50 band where ChartMogul's AI-native products retain worst (23% GRR)." The limits: the report does not name companies, the buckets are small, the sample is companies above $250K ARR, and an entry plan is not a whole product's average deal size.

Writing in public

A teardown post has a fixed shape, so a reader can check it fast. The title is the claim, for example "Cursor's pricing FAQ points daily agent users at a plan the page does not lead with." The first paragraph gives the claim, the date you checked, and what you could not verify. Then come an evidence table with a vendor source link per number, your reasoning with inference labelled, and a limits list with dated corrections.

Use only public pages and your own accounts. Never publish confidential figures from an employer. "The page does X" is a fact. "They want you to Y" is a guess, so label it.

The portfolio

A portfolio is one repo a hiring manager can scan in two minutes. Put the point of each project in the README, not the code.

gtm-portfolio/
  README.md          # who you are, 3 teardowns, 11 projects, job-market note
  teardowns/
    cursor-credits/  # post.md, evidence/, data.csv
  projects/
    01-reverse-etl/  # README: problem, result, screenshot, one decision
    ... through 11-automated-qbr/
  tools/             # capture.py, wayback_prices.py, gtm_jobs.py

Give each of the eleven course projects a card with four lines: the problem, the one number it moved or measured, a screenshot, and one decision you would defend. Lead with proof a reader can check, such as a sync run log or a backtest with its false-alarm rate. The "Ship by Friday" column in the course hub plan names each deliverable.

The job market and the interview

Use data, not headlines. The job script below collects titles, dates and posted pay from public APIs. Run it on twenty companies you want to work for, and the results tell you which skills to show. In the five-company sample the requirements cluster around production software (TypeScript, Salesforce), integration reliability, and partnership with Sales.

Clay's certifications page said on October 7, 2026 that "Clay Certifications are under construction" and that new submissions are paused. Do not plan around a new certificate. A teardown of the company you apply to, sent with your application, is a better bet.

Prepare from the postings. This is my inference, not a report of how any company interviews.

• A five-minute project walkthrough: problem, constraint, decision, number, and what broke.
• A data-contract question: "What happens if the same event arrives twice?" Stage 5 gave you the answer: an idempotency key.
• A pricing case: "Usage on the $20 plan is rising. What do you check before changing the price?"
• A judgment question: "Which of your teardown claims is weakest?" A ready list of unverified items is the right answer.

Key terms

The tools

Build the project

You will publish three teardowns, on a pricing page, a credit system and an onboarding or limit flow, and assemble a portfolio repo that holds them beside your eleven course projects, using the three scripts below. This is the no-budget path: public pages, the Wayback Machine, public job APIs, free ChartMogul reports and a free repo. The five vendors above are your subjects, and each has a free plan, so your own accounts need no card.

1. Create the gtm-portfolio repo with the folders from the layout above.
2. Copy your eleven course projects into projects/, one folder each.
3. Pick three subjects and write each claim in one sentence before you collect anything. Suggested: Cursor's credit pools, Lovable's credit pricing, Claude's usage windows.
4. Run capture.py for each pricing and docs page, and commit the evidence folders. Save any blocked page by hand and note it.
5. Run wayback_prices.py for each pricing page and keep the CSV. Check any "missing" price in a screenshot before you call it removed.
6. Save the template below as teardowns/TEMPLATE.md, copy it per subject, and fill all seven steps with a source link and a date on every number.
7. Pull one benchmark from the table, and write its sample, definition and limit beside the number you use.
8. Draft each post at 700 to 1,200 words, title as the claim, with one table or chart.
9. Fact-check every number against your saved evidence, and add a "What I could not verify" list to each post.
10. Run gtm_jobs.py on ten to twenty target companies, and write a half-page job-market note for the README.
11. Write a four-line card in the README for each course project: the problem, the one number, a screenshot, one decision.
12. Publish the three posts and the README from GitHub Pages or any blog.

Capture script. Setup is pip install playwright, then playwright install chromium.

"""Dated evidence for a teardown.
Usage: python capture.py cursor https://cursor.com/pricing"""
import datetime as dt, hashlib, json, pathlib, sys, urllib.request
from playwright.sync_api import sync_playwright


def ask_wayback(url):
    try:  # best effort: the archive rate limits with 429
        req = urllib.request.Request("https://web.archive.org/save/" + url,
                                     headers={"User-Agent": "gtm-teardown-research/1.0"})
        return urllib.request.urlopen(req, timeout=90).geturl()
    except Exception as exc:
        return f"not saved: {exc}"


def capture(slug, url):
    now = dt.datetime.now(dt.timezone.utc)
    out = pathlib.Path("evidence") / slug / now.strftime("%Y-%m-%d")
    out.mkdir(parents=True, exist_ok=True)
    with sync_playwright() as p:
        browser = p.chromium.launch()
        page = browser.new_page(viewport={"width": 1440, "height": 900})
        page.goto(url, wait_until="load")  # "networkidle" times out on pages that poll
        page.wait_for_timeout(3000)  # let client-side prices render
        page.screenshot(path=str(out / "page.png"), full_page=True)
        text = page.inner_text("body")  # what a visitor sees after scripts ran
        browser.close()
    (out / "page.txt").write_text(text, encoding="utf-8")
    (out / "manifest.json").write_text(json.dumps({
        "url": url, "captured_utc": now.isoformat(timespec="seconds"),
        "text_sha256": hashlib.sha256(text.encode("utf-8")).hexdigest(),
        "wayback": ask_wayback(url)}, indent=2), encoding="utf-8")
    return out


if __name__ == "__main__":
    print(capture(sys.argv[1], sys.argv[2]))

Price history script. It uses only the standard library.

"""Price history for one page from Wayback captures.
Usage: python wayback_prices.py cursor.com/pricing 2025 out.csv"""
import csv, gzip, json, re, sys, time, urllib.error, urllib.parse, urllib.request

UA = {"User-Agent": "gtm-teardown-research/1.0 (contact: [email protected])"}
PRICE = re.compile(r"\$\s?(\d[\d,]*(?:\.\d\d)?)")


def get(url, tries=4):
    for n in range(tries):
        try:
            with urllib.request.urlopen(urllib.request.Request(url, headers=UA), timeout=60) as r:
                data = r.read()
                if data[:2] == b"\x1f\x8b":  # id_ replays can stay gzipped, so check the gzip magic bytes
                    data = gzip.decompress(data)
                return data.decode("utf-8", errors="replace")
        except urllib.error.HTTPError as e:
            if e.code not in (429, 503) or n == tries - 1:
                raise
            time.sleep(10 * (n + 1))  # the archive answers 429 when you go fast


def captures(page, year_from):
    q = urllib.parse.urlencode({"url": page, "output": "json", "from": year_from,
                                "fl": "timestamp", "filter": "statuscode:200",
                                "collapse": "timestamp:6"})  # first capture of each month
    body = get("https://web.archive.org/cdx/search/cdx?" + q)
    rows = json.loads(body) if body.strip() else []  # the archive sends an empty body when nothing matches
    return [row[0] for row in rows[1:]]  # row 0 is the header


def prices_in(html):
    body = re.sub(r"(?is)<(script|style|svg)\b.*?</\1>", " ", html)
    return sorted({m.group(1).replace(",", "") for m in PRICE.finditer(body)}, key=float)


if __name__ == "__main__":
    page, year, out = sys.argv[1:4]
    with open(out, "w", newline="", encoding="utf-8") as f:
        w = csv.writer(f)
        w.writerow(["timestamp", "prices_found"])
        for ts in captures(page, year):
            # id_ asks for the original bytes, without the archive toolbar
            w.writerow([ts, " ".join(prices_in(get(f"https://web.archive.org/web/{ts}id_/https://{page}")))])
            time.sleep(3)  # be polite to a free public service

Job-board script. Add the companies you want to study to BOARDS.

"""Count GTM-titled roles on public job-board APIs. Usage: python gtm_jobs.py jobs.csv"""
import csv, json, re, sys, urllib.request

BOARDS = [("Anthropic", "greenhouse", "anthropic"), ("OpenAI", "ashby", "openai"),
          ("Clay", "ashby", "claylabs"), ("Ramp", "ashby", "ramp"), ("Cursor", "ashby", "cursor")]
TITLE = re.compile(r"\bgtm\b|go[- ]to[- ]market|gtme\b|revenue operations|revops", re.I)
BUILDER = re.compile(r"engineer|developer|analytics|data (scientist|analyst)|systems", re.I)


def fetch(url):
    req = urllib.request.Request(url, headers={"User-Agent": "gtm-portfolio-study/1.0"})
    with urllib.request.urlopen(req, timeout=120) as r:
        return json.load(r)


def greenhouse(token):
    url = f"https://boards-api.greenhouse.io/v1/boards/{token}/jobs?pay_transparency=true"
    for j in fetch(url)["jobs"]:
        pay = ""
        if j.get("pay_input_ranges"):
            p = j["pay_input_ranges"][0]
            pay = f"${p['min_cents'] // 100:,} - ${p['max_cents'] // 100:,}"
        yield j["title"], j.get("first_published", ""), pay, j["absolute_url"]


def ashby(name):
    for j in fetch(f"https://api.ashbyhq.com/posting-api/job-board/{name}?includeCompensation=true")["jobs"]:
        pay = (j.get("compensation") or {}).get("scrapeableCompensationSalarySummary", "")
        yield j["title"], j.get("publishedAt", ""), pay, j["jobUrl"]


if __name__ == "__main__":
    rows = []
    for company, vendor, token in BOARDS:
        jobs = list(greenhouse(token) if vendor == "greenhouse" else ashby(token))
        hits = [(company, t, "builder" if BUILDER.search(t) else "other", d[:10], pay, url)
                for t, d, pay, url in jobs if TITLE.search(t)]
        rows += hits
        print(f"{company}: {len(jobs)} open, {len(hits)} GTM-titled, "
              f"{sum(h[2] == 'builder' for h in hits)} builder")
    with open(sys.argv[1], "w", newline="", encoding="utf-8") as f:
        csv.writer(f).writerows([("company", "title", "kind", "posted", "pay", "url")] + rows)

On October 7, 2026 the first run printed 638, 822, 57, 160 and 132 open roles, with 22, 9, 12, 8 and 4 GTM-titled. Your numbers will differ, because boards change hourly: a rerun a few hours later showed one more role at Anthropic and one more at OpenAI.

Save this as teardowns/TEMPLATE.md and copy it for each subject.

# <Claim as a sentence>
Checked on: <date>   Evidence: evidence/<slug>/<date>/

CLAIM AND WHY IT MATTERS:
PRICING PAGE (tiers, prices, recommended plan):
METRIC (the unit sold, in the vendor's words):
SIGNUP AND ONBOARDING (first screen, time to first result):
CREDITS AND LIMITS (what happens at the cap):
UPGRADE PATH (what nudges the next tier):
BENCHMARK (source, sample, definition, limit):
WHAT I COULD NOT VERIFY:
WHAT WOULD CHANGE MY MIND:

What done looks like: three posts are live, each with one claim, a dated evidence table, a source link per number and a "could not verify" list. The README links the posts, shows all eleven project cards, and states your job-market finding in two sentences. Your resume and profile link to the repo. A stranger can rebuild any number from your evidence folder.

Stretch goal: run capture.py weekly for your three subjects, compare each text_sha256 to the last run, and write a note when it changes. A changed hash only means the text changed, so open the screenshots.

Common mistakes

• Repeating a lab effect as a law. "The decoy effect makes people choose Pro" needs a test on that page.
• Reading a missing price as a removed price. Raw HTML can miss prices drawn by script, as Cursor's captures may show. Confirm in a screenshot.
• No dates. A price without a "checked on" date is a rumor. Vendors change plans, as OpenAI did with its $100 Pro tier in April 2026.
• Several claims in one post, or numbers copied from listicles. The reader cannot tell which claim the evidence supports. Go to the vendor page or the original study.
• Evading blocks or using work secrets. Do not defeat a bot block or publish confidential data.

Check yourself

How to learn this faster

Learn the template first and the psychology second. Do one teardown by hand, with a browser and a spreadsheet, before you run any script. Then you know what to automate.

Skip long lists of cognitive biases. Four are enough: anchoring, the decoy effect, extremeness aversion and charm pricing.

Drill, ten minutes a day: pick a pricing page you have not seen, write the claim in one sentence, list three quotes that support it, and write one observation that would prove you wrong. If you cannot, your claim is too vague.

• Day 1: Read the template and capture one pricing page by hand. Fill steps 1 and 2 only.
• Day 2: Run capture.py and wayback_prices.py on that page. Compare the history with your screenshot.
• Day 3: Finish the template, pull one benchmark, and draft the post. Write the "could not verify" list first.
• Day 4: Fact-check every number against your evidence folder. Publish post one.
• Day 5: Write post two's claim, run gtm_jobs.py on ten companies, and draft the job-market note.

Resources

• Wayback CDX server documentationDocsFree

  Parameters for listing, collapsing by month and filtering captures.

• Wayback availability APIDocsFree

  Check whether a URL is archived and find the capture closest to a date. The page also has a Save Page Now form.

• Greenhouse Job Board APIDocsFree

  Public job data with no authentication.

• Ashby public job posting APIDocsFree

  The endpoint and pay fields used in the job script.

• Playwright for Python: screenshotsDocsFree

  Full-page screenshots, the core of dated evidence.

• ChartMogul: The SaaS Plan Mix ReportResearchFree

  A pricing-structure benchmark with its own correlation caveat.

• ChartMogul: The SaaS Retention Report, AI churn waveResearchFree

  Retention by price tier for AI-native products.

• Kyle Poyar's Growth UnhingedArticleFreemium

  A weekly newsletter on pricing and growth. Its author wrote the ChartMogul AI churn report above.

• Frederick, Lee and Baskin: The Limits of AttractionResearchPaid

  Why the decoy effect may not survive realistic stimuli. Abstract is free.

• Yang and Lynn: More Evidence Challenging the Attraction EffectResearchPaid

  The 91-attempt replication, with 11 reliable effects.

• Simonson and Tversky: Choice in ContextResearchPaid

  The source of extremeness aversion, behind good-better-best ladders.

• Anderson and Simester: Effects of $9 price endings on retail salesResearchFree

  Three field experiments on charm pricing (abstract).

Next module

This was the last module. Go back to the course hub, pick your strongest three projects, and finish your portfolio README, because those pages are what you will send to the people who hire.