Glossary

Plain-English definitions for terms you'll see across meetings, deals, the dashboard, and your own toolchain. If a term isn't here and you had to look it up, add it.

Sections: Finance & valuation · Deal flow & M&A · Sales & pipeline · Internal tools & vendors · Process & permissions · Git & GitHub · Engineering & dev · Claude & AI tooling

Finance & valuation

EBITDA

Earnings Before Interest, Taxes, Depreciation, and Amortization. A measure of how much cash a business generates from its core operations, before financing and accounting noise. Buyers care about it because it strips out things that vary by owner (debt, tax structure, asset write-downs). It's the standard input for valuing a privately held business: take this number, multiply it by an industry-specific factor, and you have a rough price tag for the whole company. You'll see it on the Deals page in valuation defaults.

Multiple

The industry-specific factor you multiply a company's annual profit by to estimate what the whole business is worth. A "5x" on $2M of profit implies $10M of business value. The factor varies by industry, size, growth, and buyer type: a fast-growing software company might trade at 8 to 12x; a slow-growing service business at 3 to 5x.

Enterprise Value (EV)

Total value of the business, regardless of how it's financed. Think of it as the price tag on the whole company before adjusting for cash and debt. Calculated by multiplying the company's annual profit by an industry-specific factor.

SDE (Seller's Discretionary Earnings)

A profit measure used for very small businesses (under roughly $2M in earnings). Adds back the owner's salary, perks, and personal expenses to show a buyer the cash a single owner who runs the place would actually take home each year.

Add-back

A one-time or owner-personal expense pulled out of a company's reported profit to show what earnings would look like under a normal owner. Common ones: the owner's personal car, family health insurance, one-time legal fees, or a relative on payroll. The third-party financial audit done during deal verification confirms which ones are legitimate.

Working Capital

The cash, inventory, and receivables a business needs day to day to keep running. Almost every deal has a working-capital target at signing: if the business is delivered with less than the target on its balance sheet, the seller credits the difference.

TTM (Trailing Twelve Months)

The most recent 12 months of financial performance, regardless of fiscal year. Used because it captures the business's current run rate better than last year's annual numbers do.

ARR (Annual Recurring Revenue)

For subscription businesses: the annualized value of contracts that renew. $1M of it means the business will generate $1M over the next year if no customer cancels.

MRR (Monthly Recurring Revenue)

For subscription businesses: the value of renewing contracts expressed as a monthly number. $100k of it means the business books $100k of recurring revenue every month.

Gross margin

Revenue minus the direct cost of delivering the product or service, divided by revenue. High (70%+) means the business has lots of money left over to pay for everything else; low (under 20%) means it's mostly a cost pass-through.

Burn rate

Monthly negative cash flow. "$200k burn" means the business spends $200k more than it brings in each month.

Runway

How many months of operations remain before cash runs out. Calculated as: cash on hand divided by monthly negative cash flow. If you have $1M and lose $200k a month, you have 5 months.

CAC (Customer Acquisition Cost)

The fully loaded sales and marketing cost to win one new customer. If a business spends $300k on sales and marketing in a quarter and lands 100 new customers, this is $3,000.

Weighted Forecast

A pipeline projection where each open deal is multiplied by its probability of closing, then summed. Raw pipeline overstates reality. Not every deal closes. This calculation fixes that:

• Deal A: $500k × 80% = $400k
• Deal B: $1M × 25% = $250k
• Deal C: $300k × 50% = $150k
• Weighted forecast: $800k

It's the honest number for "what we'll actually book." Use it when reporting expected revenue, not raw pipeline.

Deal flow & M&A

NDA (Non-Disclosure Agreement)

The first document signed in a deal process. Lets a potential buyer see confidential financial information without the right to share it. Comes before any sharing of detailed financials or the seller's pitch book.

CIM (Confidential Information Memorandum)

The sell-side pitch book the seller's banker hands to potential buyers once they've signed a confidentiality agreement. Roughly 20 to 50 pages: business overview, financials, customer mix, growth story.

IOI (Indication of Interest)

The soft, written buyer interest sent before any binding letter. Non-binding ballpark on price and structure, used by sellers to narrow the field of buyers down to a short list.

LOI (Letter of Intent)

A short, mostly non-binding document that says: "buyer and seller agree on the broad shape of a deal (price, structure, timeline) and want to move to deeper verification." Sits between handshake and the long-form purchase agreement. Promoting a deal to "LOI signed" requires Mark's or Ewing's approval. Flag it as a task at /review/tasks instead of changing the stage yourself.

Diligence (Due Diligence)

The deep verification phase between initial agreement and final paperwork. The buyer's lawyers, accountants, and operators dig into financials, contracts, customers, and operations to confirm everything the seller promised is real.

QofE (Quality of Earnings)

A third-party financial audit, paid for by the buyer, that verifies the seller's reported profit is real and that any "one-time" adjustments to it are legitimate. The deal-killer document if the seller exaggerated earnings.

Reps & Warranties

The seller's promises in the long-form purchase agreement: financials are accurate, no hidden lawsuits, no undisclosed contracts, customer list is complete, and so on. Money is held aside (or insurance is bought) at the deal's signing in case any of those promises later prove false.

Term sheet

A summary of the proposed deal terms before the long, lawyer-drafted purchase agreement. Captures price, structure, exclusivity, and key conditions. In M&A you'll often see it used interchangeably with the formal letter that locks in headline terms; in venture financing it's its own standalone document.

Earnout

Portion of the purchase price paid only if the business hits future targets (revenue, profit, retention). Bridges the gap when buyer and seller disagree on what the business is worth today: the seller earns the rest of the price by hitting the targets they claimed they could hit.

Escrow

Money held by a neutral third party at the deal's signing, released later when conditions are met. Common reasons: adjustments after the books are reconciled, payouts tied to future performance, or claims if the seller's promises turn out untrue.

Closing

The day the deal officially completes. Wire transfers, signed documents, ownership changes hands. Anything outstanding becomes a post-close cleanup item.

Rollup

Strategy of acquiring multiple small companies in the same vertical and combining them into one bigger, more valuable platform. The thesis: a combined entity at $20M of profit is worth a higher per-dollar multiple than the individual businesses were.

Bolt-on

A smaller acquisition added onto an existing platform company. Cheaper to integrate than a standalone deal because the platform absorbs it: shared back office, shared customers, shared systems.

Platform deal

The first, larger acquisition in a strategy of buying multiple companies in the same vertical. The base company that smaller add-on acquisitions get attached to.

Strategic buyer

A buyer who acquires for synergies with their existing business: cross-sell, channel, geographic expansion, removing a competitor. Usually pays more than a financial firm because the company is genuinely worth more in their hands.

Financial buyer / Sponsor

A private equity firm or investment fund. Buys for financial return, not synergy. Holds the business 3 to 7 years while improving it, then sells to another firm or to a strategic acquirer.

Handoff

The formal contract at src/lib/handoff.ts that promotes a meeting record into a deal record. Validates that the meeting has the required fields (company name, attendees, intent) before the deal is created. Promotion requires Mark's or Ewing's approval.

Sales & pipeline

Lead

Anyone identified as a possible buyer but not yet meaningfully engaged. The top of the funnel. A name plus a company, with no real signal yet that they want to talk to us.

Prospect

A potential buyer who has shown some signal of interest: replied to an email, took a meeting, downloaded a doc, asked a question. One step further than just a name on a list.

Account

A company we're targeting or working with. Multiple people at the same company roll up under it.

Contact

A specific person at a company. The unit of outreach: cold emails, sequences, and call dispositions are all tracked at this level.

TAM (Total Addressable Market)

The full universe of companies that could possibly buy from us if we had infinite reach. Big number used to size the opportunity. Roughly: "if we could sell to everyone who fits, this is what the market would be worth."

ICP (Ideal Customer Profile)

The precise description of the company we're targeting (size, industry, signals, geography). Used to filter who we go after. Narrower than the full market: focused on the ones we think we can actually win.

MQL (Marketing Qualified Lead)

A potential buyer who has interacted enough with marketing material (downloads, opens, page views) to be worth a real outreach attempt.

SQL (Sales Qualified Lead)

A potential buyer that sales has personally vetted and confirmed is a real opportunity. Note: "SQL" in engineering means Structured Query Language (the database language). Context tells you which.

Cold email

Outbound email to someone who hasn't asked to hear from us. Most of our outbound is this.

Reply rate

Percentage of outbound emails sent to strangers that get a human response. 2 to 5% is normal; above 10% is excellent.

Cadence

The pacing of a multi-step outbound campaign: how many touches, how many days between each, what mix of email, call, and LinkedIn.

Sequence

A multi-step outbound campaign that runs automatically against a list of people (email, wait, email, call). Each step is tracked per person.

SDR (Sales Development Rep)

The role that runs outbound, qualifies new buyer interest, and books first conversations. Their performance shows up in get_sdr_performance.

Discovery call

The first real conversation with a potential buyer. Goal is to qualify fit and uncover pain, not pitch. Usually 20 to 30 minutes.

Disposition

The outcome label on a call attempt or outbound touch (e.g. "interested," "not now," "wrong number," "voicemail"). How outbound activity gets categorized for reporting.

Snoozed contact

A person in our system temporarily paused: not deleted, just hidden from active outreach until a reactivation date. Used when someone says "not now, talk to me in Q3."

Internal tools & vendors

Doppler

The single source of truth for all credentials (keys, passwords, tokens). Project: clawdbot, configs: dev and prd. Run any script that needs secrets via doppler run --project clawdbot --config dev -- <command>. Never hardcode keys, use .env files, or paste keys in Slack.

Exa.ai

A paid web-search service we use to enrich company and person data. Smarter than Google for structured research but costs money per call. Every call is metered against the $25/day intern budget (see src/lib/circuit-breaker.ts). Calls get blocked and Ewing is alerted in Slack if you blow the budget.

Clay

A paid enrichment vendor that fills in missing data on companies and people (employee count, recent news, email addresses, tech stack). Metered against the same $25/day intern budget as Exa, via the budget guard at src/lib/circuit-breaker.ts.

Lob

The vendor we use to send physical mail (printed letters, postcards). Expensive per piece, so any send notifies Ewing in Slack.

Supabase

Our Postgres database and authentication layer. Interns never query it directly. All writes go through our own server routes in src/app/api/.

Vercel

Where chapter.guide is hosted and deployed. Every proposed code change gets its own temporary preview URL (the "Building" comment from vercel[bot] you'll see on GitHub).

Fireflies

A meeting-transcription tool that records and indexes every call. Source for the Meetings page.

Granola

A meeting-notes tool that captures context, summaries, and transcripts during calls. Used alongside our other meeting recorder.

Slack alert

An automated message posted to Ewing in Slack when something significant happens: budget breach, expensive vendor call, deal-stage change request. Configured via the budget guard and the feature registry.

Circuit breaker

The budget guard at src/lib/circuit-breaker.ts. Tracks how much each intern has spent on paid vendors today, blocks new calls when the cap is hit, and notifies Ewing in Slack.

Webhook

A URL that an external system calls (POSTs to) when something happens: a code change is opened, a meeting is transcribed, a person is added to a list. Lets us react to events live instead of asking "anything new yet?" on a timer.

Engine

The Python background-job layer at engine/. Runs scheduled work: meeting sync, prospect enrichment, scoring. Charlie and Bear don't write engine code, but you'll see its output in the dashboard.

Aegis

Our internal naming and file-output convention enforcer. Common rule: HTML reports use double-underscore filenames (AEGIS__topic__date.html).

Maxswarm

Our multi-agent orchestrator. A "swarm" is a coordinated set of agents (market-analyst, hunter, writer, debrief) that runs together to produce a research output. Charlie and Bear's tasks deploy as missions in this system.

Skill (Claude skill)

A reusable Claude prompt and tool bundle stored in skills/. Symlinked into ~/.claude/skills/ on every machine. Examples: dash-scrubber, init, review.

Process & permissions

Tier

Permission level on a feature: intern (Charlie & Bear), operator (Mark/Ewing), admin (Ewing only). Checked via canUse(feature, actor) in src/lib/features/permissions.ts.

Feature flag

Every feature in the app is registered in src/lib/features/defs/ with a permission level. If it's not registered or you don't have permission, the action won't fire. New features follow the lifecycle: design, build, test, live.

Task queue

/review/tasks is where flagged actions go for Ewing's review. When in doubt, create a task instead of guessing. Deal-stage changes and meeting-to-deal promotions both flow through here.

Pre-commit hook / dash-check

The local script and CI job that blocks em dashes (—) and other AI-tell punctuation from getting into the codebase. If your save-to-history step fails, run dashcheck <file> --in-place to auto-fix the file, then try again.

Git & GitHub

GitHub

The cloud service that hosts our codebases, runs automated tests on changes, and is where code review happens. Our org is ewing-operating-system.

Repo (repository)

A single project's codebase plus its full history of changes. Our main one is ewing-operating-system/next-chapter-os, which contains everything: the website, the Python background jobs, Claude skills, and content.

Branch

A named line of development off main. You always work on one (e.g. claude/intern-glossary-terms-GfMFd): save your changes there, send them to GitHub, and open a request to fold the changes back into main.

Worktree

A separate working copy of the codebase on a different line of development, sharing the same project history. Lets you keep your main checkout untouched while Claude works on a side project in an isolated directory.

Commit

A saved snapshot of changes in git, with a message describing what changed and why. Each one captures a single "moment" in the history of the project. Multiple snapshots stack up on a working line before being submitted for review.

PR (Pull Request)

A proposed change to the codebase: your saved snapshots plus a description, opened on GitHub for review before they get folded into main. Every change you make goes through one.

Diff

The line-by-line changes between two versions of a file: what was added, what was removed. git diff shows yours locally; the cloud platform shows it between your in-progress changes and main.

Merge

Combining two lines of development together so that one absorbs the other's changes. The standard review-and-approve flow ends with your changes being merged into main.

Rebase

Replaying your saved changes on top of the latest main, so the project history reads cleanly. Used when main has moved forward while you were still working on something.

Merge conflict

What happens when two parallel sets of changes touch the same line of the same file in different ways. Git can't decide which version wins, so you have to pick manually and then continue.

Pull

Downloading the latest changes from the cloud copy of the project and folding them into your local copy. git pull origin main brings your local main up to date.

Clone

Downloading a project from the cloud to your machine for the first time. git clone <url> creates a local copy with full history.

Engineering & dev

JavaScript

The programming language the web runs on. What most of our website (src/) and the deal-room app (apps/deals/) are written in. Files end in .js, .jsx, .ts, or .tsx.

TypeScript

A version of the language the web runs on, with type annotations added so the compiler can catch a class of bugs before the code runs. Files end in .ts or .tsx.

Next.js

The framework chapter.guide is built on. Handles routing, server-side rendering, and the server endpoints we expose. Pages live in src/app/<route>/page.tsx; server endpoints live in src/app/api/<route>/route.ts. Note: our version has breaking changes from stock Next.js, so always read the relevant guide in node_modules/next/dist/docs/ before writing new code.

React

The UI library that powers most modern websites, including ours. You build pages by composing small reusable pieces of UI. If you've heard "components, props, state," this is where those concepts come from.

Component

A reusable piece of UI: a button, a table, a header. Modern websites are built by composing trees of these. Lives in src/components/.

Endpoint

A URL the server responds to. Ours live at src/app/api/<path>/route.ts. The intern rule: all data writes go through one of these, never direct database queries.

Environment variable

A named value the running program reads from its environment (process.env.EXA_API_KEY). Our credential manager injects them at runtime so secret keys never get checked into git.

Localhost

The web address http://localhost:3000. The dev server running on your own machine, only visible to you. While you make changes, the site becomes browsable at this address before any of it ships.

Build

The compile-and-bundle step that turns source code into the production artifact our hosting platform deploys. Run locally via npm run build. The cloud platform runs it automatically on every proposed change.

Lint

A static check that catches style and pattern problems before they hit production. Run locally with npm run lint. Different from compilation: linting cares about style and risk, not whether the code works.

CLI (Command-Line Interface)

Any program you run by typing commands instead of clicking buttons. git, doppler, npm, and claude are all examples; most of our tooling is run this way.

Terminal

The app on your computer where you type text commands and see their output. On Mac it's called Terminal.app, or iTerm if you prefer. The black or dark window with a blinking cursor.

Bash

The default shell language inside most terminal apps. What you're writing when you type ls, cd, git status, or string commands together with &&. Claude's Bash tool runs commands in this same shell.

Shell command

Any single instruction you type into a command-line window (e.g. git status, ls). The building block that gets strung together into longer scripts.

Chain commands

Running multiple commands in sequence on one line. && runs the next only if the previous succeeded (task1 && task2); ; runs them regardless of success; | (pipe) feeds the output of one into the input of the next (task1 | task2).

ls

List files in the current directory. Add -la to also see hidden files and details.

cd

Change directory. How you move around the filesystem (cd src/app/deals to step into the deals page folder; cd .. to go back up one level).

Grep

A command-line tool that searches files for a pattern (grep "EBITDA" content/*.md). The fastest way to locate a string or symbol in the codebase.

npm (Node Package Manager)

The command-line tool that installs and runs the third-party libraries our website depends on. npm install (install dependencies), npm run dev (start dev server), npm run build (production build).

Claude & AI tooling

Claude effort

The thinking-effort dial that controls how hard Claude reasons before answering. Higher means better answers on hard problems, but slower and more expensive. Use higher on architectural questions, lower on simple edits.

Claude Cowork

The shared-session mode where more than one person or agent is in the same Claude Code session. Useful for pairing with Ewing or another intern on a tricky task.

Claude Chrome

The Claude browser extension that runs inside Chrome. Lets Claude read and act on whatever web page you're on (Gmail, dashboards, articles) without you having to copy-paste the context over.

Terminal Claude

Claude Code running inside your local command-line window (the claude command), as opposed to Claude Code on the web or in an IDE. This is the version that can run shell commands, edit files locally, and use git directly.

MCP (Model Context Protocol)

The open standard that lets Claude talk to external services (chat platforms, databases, calendars, meeting tools). Each external server exposes a set of capabilities Claude can call directly. That's how Claude posts comments on proposed code changes or reads meeting transcripts.

API (Application Programming Interface)

The contract that lets one piece of software call another. In our world it usually means either (a) our own server routes at src/app/api/* (which all intern data writes must go through), or (b) external paid services we call from code (like our enrichment vendors and Anthropic).

Token

The unit Claude reads and bills in. Roughly 4 characters of English per one. Conversations and prompts are measured and priced in these.

Context window

The total amount of text Claude can hold in memory for one session: system prompt plus conversation history plus current input. When you near the limit, the harness compresses older messages.

Tool use

When Claude calls one of its tools (Read, Edit, run a shell command, talk to an external service) to take an action in the world, instead of just generating text. Every file edit, command run, and code-review comment Claude makes counts as one of these.

Subagent

A specialized Claude agent the main agent can spawn for a focused task (Explore, Plan, Review). Lets the main agent stay focused while a focused worker handles a deep search or long analysis.

Slash command

A shortcut you type in Claude Code starting with / (e.g. /review, /init, /security-review). Triggers a packaged routine or built-in command without you having to write out the full prompt.

CLAUDE.md

The project instructions file Claude reads at session start. Lives at the project root and any subdirectory. Contains the rules of the road for this codebase. Read both CLAUDE.md and AGENTS.md at the project root before writing code.