Should a Platform Lead Self-Host an AI Coding Lane or Keep a Free One? Use This 6-Field Fit Card

Monday, 9:40 a.m. An AI-assisted change is already in production. The invoice is still zero. The on-call thread is not.

Can you replay the exact lane that wrote the diff? If the answer is a shrug, the “free” column is already charging you — just not on a card statement. This piece is a fit card for that moment. It is not a vendor bake-off, and it is not a claim that any one runtime is “better at coding.”

I treat the numbers below as a labeled hypothetical. Fill your own. A scorecard is a conversation tool, not objective truth. Which single threshold would reverse your keep-free decision?

The constraint that can flip the call

A free hosted lane is cheap until three things collide: you cannot pin the model and runtime, review happens beside the PR instead of in it, and people hide usage so the lane stays free. Self-hosting is expensive until those three things are the job.

Paid SaaS sits in the middle only if the contract actually buys pin, boundary, and an exit. Seat stickers do not buy those. Neither do token stickers.

So the question is not “is free good?” It is: where should this squad’s coding lane live for the next 45 days — free hosted, paid hosted, or self-hosted — given replay, data, incentives, and exit?

Define the variables before you score

Write these on a wiki page. If a field has no owner, it is not a field. It is a vibe.

Variable	Meaning	Unit	Owner
R	Can we re-run the same model + runtime + prompt pack against the same SHA?	yes / partial / no	Platform
B	What leaves the building, and is that allowed in writing?	ok / exception / blocked	Security
W	Does the lane sit in the PR path, or in a side chat that reviewers never see?	in-band / side	EM
I	Are people hiding prompts, pasting secrets, or dual-running a shadow tool?	clean / leak	EM
H	Extra human hours the lane creates: review, rollback, incident archaeology	hours / week	EM
X	Hours to leave: export, re-onboard, rewrite rules, kill the exception	hours	Platform
C_h	Fully loaded cost of an engineering hour	currency / hour	Finance partner
C_run	Invoice or infra for the lane itself	currency / 45 days	Platform

H is the expensive number. C_run is the loud one. Do not let the loud one win by default.

Three columns, not two slogans

Score the same squad three ways. Do not skip a column because it feels unfashionable.

1. Keep a free hosted lane. Invoice near zero. You accept whatever pin, quota, and region the operator gives you this month.
2. Buy a hosted lane. You are paying for a contract: pin, logs, DPA language, support, and a kill switch you can actually pull.
3. Self-host. You buy replay and boundary with owner hours. The GPU bill is not the whole bill.

Some teams park column 1 on a product that currently offers free model access and a free server option. Disclosure: This article was prepared as part of MonkeyCode's product outreach. I am not treating those offers as permanent, unlimited, named-model, or benchmarked. They are a perishable input to column 1. If they change next week, the card should still work.

Hard gates (these are not scores)

If any gate fails, stop scoring and pick the column that clears the gate. Scores do not override law, paging, or a lying incentive.

• Pin gate. The next Sev-2 needs a model id, runtime id, and prompt-pack hash on the PR. If the lane cannot emit those, column 1 is closed for that repo.
• Boundary gate. Customer data, secrets, or production configs cannot ride a lane with no written exception. B = blocked kills hosted-free for that surface.
• Incentive gate. If people dual-run a shadow tool to “protect” the free lane, you do not have adoption. You have a leak. Freeze expansion.
• In-band gate. If reviewers cannot see the prompt, the file list, and the rejection path in the PR, W = side. Side channels do not get to touch auth, payments, or migrations.

Who should not use this card? A solo hobby repo with no pager and no customer data. You do not need a six-field ledger to autocomplete a side project. Also skip it if nobody will own R and X. An orphaned self-host is just a future incident with extra YAML.

Worked example (hypothetical, 8-person squad)

Assume C_h = 95 currency units per hour. Forty-five day window. One platform owner at 0.25 FTE on the lane. No invented vendor list prices — C_run is what you were quoted or what your cloud bill actually did.

Column 1, free hosted

• R = no (no pin you control)
• B = exception (public tickets only; prod configs banned)
• W = side for two engineers who live in chat
• I = leak starting in week three (paste of a staging URL)
• H = 5.5 extra review/archaeology hours per week
• C_run = 0
• X = 6 hours to leave

Loaded 45-day human cost: 5.5 * 6.4 weeks * 95 ≈ 3,344. Exit is cheap. Replay is not.

Column 2, paid hosted

• R = partial (vendor pin, not your binary)
• B = ok on the paper you actually signed
• W = in-band after you force the PR check
• I = clean if the paid seat is the only blessed path
• H = 2.0 hours / week
• C_run = your quote
• X = 20 hours if the export is clumsy

Human cost: 2.0 * 6.4 * 95 ≈ 1,216 plus C_run plus a slower exit.

Column 3, self-host

• R = yes if you freeze image digest + model artifact + prompt pack
• B = ok on your network
• W = in-band only if you build the PR check; the box does not do that for you
• I = leak if the server is up and the workflow is annoying
• H = 1.5 hours / week once the workflow exists, plus 0.25 FTE owner (0.25 * 36 hours * 95 ≈ 855 in 45 days)
• C_run = power, box, storage, backups — your bill, not a blog benchmark
• X = 40 hours if you are the only person who knows the runbook

Self-host wins on pin and boundary. It loses if the owner is fictional.

Would you still keep column 1 if H is 5.5 and R is no? Only if this squad never pages, never handles customer data, and you have already scheduled the expiry.

Sensitivity: the one slider that reverses the call

Hold everything else still. Move one variable.

• If H drops under ~2 hours/week because the free lane is in-band and boring, column 1 can survive a 45-day exception. The invoice was never the point.
• If R stays no and you have had one unreplayable incident, column 1 is done for that repo. Do not “try one more sprint.”
• If C_run for paid hosted exceeds the H savings, you are buying a brand, not a pin. Demand the pin in writing or stop.
• If self-host X is 40 hours and the owner takes leave, you do not have a platform. You have a pet.

Break-even against staying free, in words: column 2 or 3 is cheaper when (H_free - H_alt) * weeks * C_h + incident_risk_you_will_actually_write_down > C_run_alt + owner_hours_alt * C_h + (X_alt - X_free) amortized. If you will not write the incident risk down, set it to zero and admit you are gambling.

The 6-field fit card (copy this)

Score each field 0, 1, or 2. Higher means “this column fits this squad for 45 days.” Cap any column at 0 if a hard gate failed.

# fit-card.45d.yaml — conversation tool, not truth
squad: payments-api-8
window_days: 45
owner: platform-lead
expiry: 2026-10-31
hard_gates:
  pin: fail-closed
  boundary: fail-closed
  incentive_leak: freeze-expansion
  in_band_for_sensitive_paths: required
columns:
  free_hosted:
    R: 0   # no pin we control
    B: 1   # exception, public tickets only
    W: 0   # side chat still exists
    I: 0   # leak observed
    H: 0   # 5.5h/week extra
    X: 2   # cheap to leave
  paid_hosted:
    R: 1
    B: 2
    W: 2
    I: 2
    H: 1
    X: 1
  self_host:
    R: 2
    B: 2
    W: 1   # only if the PR check ships
    I: 1
    H: 1
    X: 0   # expensive pet risk
gates_failed:
  free_hosted: [pin, incentive_leak]
recommendation: "Do not expand free_hosted. Pick paid_hosted or self_host after pin is evidenced."

Run a dumb scorer so the meeting cannot hide in adjectives:

# fit_card.py — labeled example, not a benchmark
COLUMNS = {
    "free_hosted": {"R": 0, "B": 1, "W": 0, "I": 0, "H": 0, "X": 2},
    "paid_hosted": {"R": 1, "B": 2, "W": 2, "I": 2, "H": 1, "X": 1},
    "self_host": {"R": 2, "B": 2, "W": 1, "I": 1, "H": 1, "X": 0},
}
GATES_FAILED = {"free_hosted": ["pin", "incentive_leak"]}
WEIGHT = {"R": 3, "B": 3, "W": 2, "I": 2, "H": 2, "X": 1}  # pin/boundary dominate

for name, scores in COLUMNS.items():
    if GATES_FAILED.get(name):
        print(f"{name}: GATE FAIL {GATES_FAILED[name]} -> 0 (do not rank)")
        continue
    total = sum(WEIGHT[k] * scores[k] for k in WEIGHT)
    print(f"{name}: weighted {total} / {sum(WEIGHT.values()) * 2}")

That script will print a zero for the free column. Good. The meeting should argue the inputs, not the printout.

Make replay a merge rule, not a slide

If you cannot pin, you cannot choose column 1 for a paged repo. Put the evidence on the PR. Something this boring:

# required labels on every AI-touched PR (policy, not a product pitch)
echo "lane=$LANE"
echo "model_id=$MODEL_ID"          # empty => fail closed
echo "runtime_digest=$DIGEST"      # empty => fail closed
echo "prompt_pack=$PACK_SHA"
echo "files=$(git diff --name-only origin/main)"

Empty model_id is a failed pin gate. Do not negotiate it in Slack after the page.

Owner, expiry, exit

• Owner: the platform lead who can turn the lane off. Not “the squad.” Not “AI champions.”
• Expiry: 45 days, on a calendar invite, with the six fields filled again. Exceptions expire. They do not mellow.
• Exit criteria for column 1: pin gate fail, one unreplayable incident, I = leak, or H still above the number you wrote down on day 0.
• Exit criteria for column 3: owner drops below 0.15 FTE, backups untested, or W slides back to side chat.
• Archive rule: keep the YAML, the PR labels, and the incident note. Delete the exception ticket so it cannot be copy-pasted as policy.

Limitations

This card will not tell you which model writes prettier React. It will not rank vendors. It will not invent an ROI from tokens. It under-weights rare, huge incidents unless you write that risk as a number you are willing to defend. It over-weights process if your company never pages.

Do not use it to justify a self-host vanity cluster. Do not use it to keep a free lane alive after a leak because the invoice is flattering.

What would reverse it?

I would keep a free hosted lane for 45 days if R becomes partial or better, W is in-band, I stays clean, and H is under two hours a week on a non-sensitive repo. I would self-host the day B is blocked and we still need a lane. I would pay the day pin and logs are in the contract and owner hours for self-host would exceed the quote.

Your turn. Which variable — R, H, or I — would reverse the column you are defending this week? Write that number next to an expiry date. Then run the card again before the exception quietly becomes the architecture.