Co-Founder Equity for Developers: Splits, Vesting and Dilution, With the Math in Code

You and a friend have a repo, a domain name and a few months of evenings behind you. Then one of you asks the awkward question: how do we split the company?

It's one of the first and hardest conversations in a startup, and it only gets harder after every customer, hire and funding round. The arithmetic is easy. The hard parts are agreeing which contributions count and what happens if someone leaves.

This post walks through the model behind our free founder equity split calculator in JavaScript, then adds vesting, a co-founder leaving early, and what funding rounds do to both of you.

The example founders are Riley, a developer who had the idea and is building the product, and Morgan, who knows the industry and will sell into it. Both are going full time.

This isn't legal or tax advice. The founders and numbers are made up. Agree your own terms in a founders' agreement and get a lawyer to draft it.

TL;DR

1. A weighted-factor split

The calculator scores each founder from 0 to 10 on six factors, multiplies each score by the factor's weight, and gives each founder their share of the total points:

const FACTORS = [ { label: "Full-time commitment", weight: 3 }, { label: "Idea and early work", weight: 1 }, { label: "Domain expertise", weight: 2 }, { label: "Building the product", weight: 2 }, { label: "Sales and fundraising", weight: 2 }, { label: "Money put in", weight: 1 }, ]; const round1 = (n) => Math.round(n * 10) / 10; // Points = score × weight, summed. Each founder's share of the points is their equity. function equitySplit(factors, scores) { const points = scores.map((s) => factors.reduce((sum, f, i) => sum + f.weight * s[i], 0)); const total = points.reduce((a, b) => a + b, 0); if (total === 0) return scores.map(() => round1(100 / scores.length)); // no scores: split equally return points.map((p) => round1((p / total) * 100)); } // commit idea domain build sales money const riley = [10, 8, 6, 9, 4, 5]; const morgan = [10, 4, 8, 3, 9, 5]; equitySplit(FACTORS, [riley, morgan]); // [50.6, 49.4] 

Riley scores 3×10 + 1×8 + 2×6 + 2×9 + 2×4 + 1×5 = 81 points and Morgan 79, out of 160. These are the calculator's default scores, so you can check the result there.

Commitment counts three times as much as the idea, because equity mainly rewards the years of work ahead. The output is a starting point for a conversation, not a final answer.

2. Equal or unequal?

Riley and Morgan settle on 50/50, a common outcome. Many investors are comfortable with equal or near-equal splits between full-time founders, because they signal partnership, and small differences in contribution rarely justify a large gap. Even the most lopsided idea score barely moves this one:

// Index 1 is "Idea and early work": Riley gets full credit, Morgan none equitySplit(FACTORS, [riley.with(1, 10), morgan.with(1, 0)]); // [52.5, 47.5] 

Arguing over who had the idea is arguing over about two points. An equal split fits badly when commitments really differ, though. Suppose Morgan keeps a day job for the first year:

// Index 0 is "Full-time commitment": Morgan scores 4 of 10 instead of 10 equitySplit(FACTORS, [riley, morgan.with(0, 4)]); // [57, 43] 

The gap grows from about 1 point to 14. A co-founder who joins much later usually gets less too, reflecting the risk already taken and the progress made. Either way, a gap should reflect future roles, not who had the idea.

Keep money out of the split. If Morgan puts in $20,000, treat it as a loan or an investment on the same terms as outside investors, so the split reflects work.

3. Vesting: founders earn their shares too

A 50/50 split assumes both founders stay. Vesting covers the case where one doesn't. The common schedule, for founders and employees, is four years with a one-year cliff: nothing vests in year one, 25% vests at the one-year mark, and the rest monthly after that.

Founders already own their shares, so founder vesting runs in reverse: a founder who leaves early forfeits, or has to sell back, the unvested part, often at a nominal price. Investors often ask for it, sometimes giving credit for time already worked.

// Four years, one-year cliff, monthly after that. `credit` = months worked before vesting began. function vestedShares(shares, months, { cliff = 12, total = 48, credit = 0 } = {}) { const m = months + credit; if (m < cliff) return 0; return Math.floor((shares * Math.min(m, total)) / total); } const founders = { Riley: 5_000_000, Morgan: 5_000_000 }; // 50/50 of 10M shares // The founders' split after one of them leaves and gives up their unvested shares. function afterLeaving(holdings, leaver, months, terms) { const kept = { ...holdings, [leaver]: vestedShares(holdings[leaver], months, terms) }; const total = Object.values(kept).reduce((a, b) => a + b, 0); return Object.fromEntries(Object.entries(kept).map(([name, n]) => [name, round1((n / total) * 100)])); } afterLeaving(founders, "Morgan", 11); // { Riley: 100, Morgan: 0 } afterLeaving(founders, "Morgan", 18); // { Riley: 72.7, Morgan: 27.3 } 

Leaving at 18 months, Morgan keeps 1,875,000 shares (37.5%) and 3,125,000 go back to the company. Of the shares the founders still hold, Riley has 72.7%. A month before the cliff, Morgan would keep nothing.

Without vesting, Morgan would keep 50% of a company they no longer work on, often called dead equity. The cap table explainer lists it among the common mistakes.

Six months of work before signing can count too. With that credit, Morgan is past the cliff nine months after signing:

afterLeaving(founders, "Morgan", 9, { credit: 6 }); // { Riley: 76.2, Morgan: 23.8 } 

Two more clauses change what a leaver keeps. Under good leaver and bad leaver terms, someone who leaves through illness, say, may keep vested shares, while someone who joins a competitor or is dismissed for misconduct may have to sell even vested shares back at a low price. Acceleration vests shares early on a sale of the company (single trigger), or only if the founder also loses their role after it (double trigger).

Investors may also ask founders to restart vesting at a funding round. The term sheet explainer covers that, and the vesting, cliffs and ESOPs explainer has the full schedule.

4. Funding rounds dilute you both alike

A priced round issues new shares, so every percentage falls while share counts stay the same. Term sheets often also ask for an employee option pool, often 10–15% of the company after the round, created before the investment, inside the pre-money valuation, so it comes out of the existing holders rather than the new investor. A share-level model of both:

const sum = (o) => Object.values(o).reduce((a, b) => a + b, 0); // One priced round. The pool is topped up to `poolPct` of the post-round company first. function pricedRound(cap, { name, preMoney, raise, poolPct = 0 }) { const next = { ...cap }; const investorPct = raise / (preMoney + raise); const pool = (poolPct * (sum(next) - (next.pool ?? 0))) / (1 - investorPct - poolPct); if (pool > (next.pool ?? 0)) next.pool = Math.round(pool); const price = preMoney / sum(next); // per share, on the fully diluted count next[name] = Math.round(raise / price); return next; } const ownership = (cap) => Object.fromEntries(Object.entries(cap).map(([holder, n]) => [holder, round1((n / sum(cap)) * 100)])); const rounds = [ { name: "preSeed", preMoney: 2e6, raise: 0.5e6 }, { name: "seed", preMoney: 8e6, raise: 2e6, poolPct: 0.1 }, { name: "seriesA", preMoney: 40e6, raise: 10e6, poolPct: 0.12 }, ]; let cap = { ...founders }; for (const round of rounds) { cap = pricedRound(cap, round); console.log(round.name, ownership(cap)); } // preSeed { Riley: 40, Morgan: 40, preSeed: 20 } // seed { Riley: 28, Morgan: 28, preSeed: 14, pool: 10, seed: 20 } // seriesA { Riley: 21.2, Morgan: 21.2, preSeed: 10.6, pool: 12, seed: 15.1, seriesA: 20 } 

The pool line solves for the pool size that will be poolPct of the company once the new investor's shares are added. Each round sells 20%, inside the 10% to 25% that priced rounds commonly sell.

The founders fall together. Each round and pool top-up shrinks both founders by the same factor, so 50/50 stays 50/50, and 60/40 would stay 60/40.

The pool is a cost to founders. Run the same rounds without it:

let noPool = { ...founders }; for (const round of rounds) noPool = pricedRound(noPool, { ...round, poolPct: 0 }); ownership(noPool).Riley; // 25.6 

That's 4.4 points per founder, paid for by the founders and the earlier investors. It's why the pool's size is worth negotiating against a real hiring plan. The pre-money vs post-money explainer shows what it does to your effective valuation.

The slice is smaller but worth more. After pre-seed, Riley's 40% of a $2.5M company was worth $1M on paper. After Series A, 21.2% of $50M is about $10.6M.

5. Put it in writing

A "50/50?" "Sure!" exchange in a chat isn't a founders' agreement. Agree these points and get a lawyer to draft it:

• The split, and the scores behind it.
• Vesting: length, cliff, and any credit for time already worked.
• Roles and decision-making: who does what, and how two 50% owners settle a disagreement.
• Leaving: unvested shares, the buy-back price, and good and bad leaver terms.
• Acceleration if the company is sold.
• Money put in: a loan or an investment, on clear terms.
• Intellectual property: the code and anything else you've built, assigned to the company. Pre-seed investors look for founders' shares issued and vesting, and IP assigned.

Once you raise, founder vesting is usually written into the shareholders' agreement, so settle it between yourselves first.

Mistakes that cause trouble later

• Splitting by who had the idea. In the model it's worth about two points.
• No vesting. A co-founder who leaves at 18 months keeps half the company.
• Paying for cash with equity. Money put in should be a loan or an investment.
• Equity promised in chats and emails. Unrecorded promises tend to add up to more than planned.
• Forgetting the pool. Model each founder's stake after the pool and a few rounds, not just at founding.

To run your own numbers, score yourselves in the equity split calculator and model rounds and pool top-ups in the dilution calculator. When you start hiring, the stock option calculator shows what a grant is worth to the person receiving it. All free at startupreader.com/tools.

Disclosure: I'm part of the StartupReader team. This post was drafted with AI assistance, and every formula and figure was checked against the linked explainers and by running the code above.