# Free SDK vs paid kit: when buying actually pays for itself at checkout > Already on the free SDK? Use a four-piece payback test — screens, schema, auth/billing, agent spine — to decide if a paid OTF kit is worth checkout. > By Dave · 2026-09-18 > Source: https://otf-kit.dev/blog/free-sdk-vs-paid-kit-when-to-buy You already run the free SDK. Screens look decent. Components render the same on web and native. Then you open checkout for a full-stack kit and freeze — not because the product is unclear, but because you cannot name the moment the purchase pays for itself. That hesitation is rational. The free layer is real work you can keep forever. A paid kit is a different bet: you are buying time and structure, not another component catalog. The useful question at checkout is narrow. What actually changes in the repo the day after you buy, and how many calendar days of wiring does that replace? This post answers that buyer question only. For adjacent pricing judgment once you own a product spine, see [Price your first paid tier like a promise you can keep shipping](/blog/pricing-first-tier-ai-built-app). That piece is about pricing the promise once you ship. This one is the checkout math: when a paid kit stops being optional and starts paying for itself. ![Byte pauses at a blank fork between free components and a paid kit](https://cdn.otf-kit.dev/blog/free-sdk-vs-paid-kit-when-to-buy/inbody-01-hesitation-20260918a.png) ## What checkout hesitation usually means Hesitation rarely means "I hate the preview." It means you are comparing two different product shapes and calling them the same thing. The free SDK is a UI and design-system layer: components, themes, and source you own and edit. You can ship an app on that alone. Plenty of builders do. A paid kit is a vertical product spine — domain screens, a real schema, auth and billing paths, and agent configs that already know where new work goes. Current tiers and commercial terms live on the [pricing page](https://otf-kit.dev/pricing); this article will not invent sticker prices. Use that page for numbers. Use this page for the decision rule. If you only need buttons, sheets, and charts, stay on the free SDK. Checkout is the wrong surface for that need. If you are about to spend a sprint inventing the product spine the kit already ships, the purchase starts to look like calendar insurance. ## What a paid kit actually changes in the repo Think in four concrete deltas — not marketing bullets, but folders and files you will otherwise write by hand. **Screens.** Not a blank navigation shell. Domain flows: onboarding, home, tracking, settings, empty states, and the error paths users hit on day two. For a concrete example, the [Fitness Kit](https://otf-kit.dev/templates/fitness-kit) ships workout, nutrition, and progress surfaces already connected to the rest of the stack. You still customize copy and branding. You do not start from "create ten screens and hope the navigation model holds." **Schema.** A real database shape with migrations and seed data, not a demo JSON file. Tables for users, domain entities, and the relationships your screens already assume. Agents and humans both extend a known model instead of inventing one mid-feature. **Auth and billing.** Sign-in, session persistence, and a path to take payment that is wired into the same codebase as the UI. You still choose providers and keys. You do not spend the first two weeks discovering that auth and checkout were "left as an exercise." **Agent spine.** CLAUDE.md, Cursor rules, and tested prompts that describe the kit's conventions. That is the difference between an agent that edits the right folders and one that invents a second pattern every session. The kit is readable to the tools you already use to ship. Those four are what changes at checkout. Everything else — polish, theming, component count — mostly overlaps the free SDK you already have. ![Dex and Nova assemble four blank blocks into one product spine](https://cdn.otf-kit.dev/blog/free-sdk-vs-paid-kit-when-to-buy/inbody-02-spine-20260918a.png) ## A simple payback test you can run this week Do not price the kit against "how nice the demo looks." Price it against days you will spend recreating those four pieces on your own stack. Write four lines, one per piece: 1. Screens — how many domain flows must exist before a stranger can complete one valuable job? 2. Schema — do you already have migrations, seed data, and role-safe queries, or will you design them under pressure? 3. Auth and billing — is session refresh and a real purchase path already production-shaped, or still a spike? 4. Agent spine — can an agent add one feature using only your repo docs, or will it guess? Give each line a honest day count for your team size. Sum them. Then open [pricing](https://otf-kit.dev/pricing) and compare the one-time kit cost to that sum at your real hourly rate — contractor invoice, founder salary, or agency billable. If the sum is larger than the kit by a clear margin, the purchase is buying back calendar, not buying hope. If three of the four lines are already done in your repo, stay free. Buying a kit to replace finished work is how teams feel buyer's remorse. If two or more lines are still blank and you have a ship date, the kit is usually the cheaper path even before you count review cycles and agent thrash. ## When staying on the free SDK is the right call Stay free when the product is still a component experiment: design tokens, navigation experiments, or a marketing site that does not need accounts. Stay free when you already own a production schema, auth provider, and billing webhooks, and you only wanted a shared UI layer across web and native. Stay free when you are evaluating libraries and have not committed to a vertical yet. The free SDK is not a trial that expires into a kit. It is the permanent UI layer under the kits. That separation is intentional. Do not buy a kit to get more components. You already have them. For how to price the first paid tier after you have a spine, see [pricing-first-tier-ai-built-app](/blog/pricing-first-tier-ai-built-app). ## When the paid kit pays for itself Buy when the next milestone is a stranger completing a job in a real product, not a designer approving a screen. Buy when auth, schema, and billing are on the critical path of the next two weeks. Buy when you will run Cursor, Claude, or similar tools hard against the codebase and need one convention set instead of three invented ones. Buy when rewriting those four pieces would slip a launch past a store deadline, a client date, or a fundraising demo. A concrete fitness-shaped example: you need onboarding, workout logging, nutrition, and progress charts on iOS, Android, and web, with Postgres and an API already talking to the client. Inspect the live [Fitness Kit](https://otf-kit.dev/templates/fitness-kit) preview, then run the four-line day count. If your estimate is "we will invent this under deadline," checkout is the cheaper decision. If your estimate is "we already have this spine and only need OTF components," close the tab and keep shipping on the free SDK. If you are still choosing among starters in general — upgrade path, backend spike, agent readability — use the selection procedure in [Choose a starter kit without a rewrite](/blog/choose-starter-kit-without-rewrite). That post is about picking any kit once. This post assumes you already know OTF's free layer and are deciding whether to buy one OTF kit at checkout. ## How to decide in one sitting Block ninety minutes. Open the kit preview you care about. Open your empty or half-built repo. Open [pricing](https://otf-kit.dev/pricing). Fill the four-line day count without optimism bias — use the worst week you had last month as the conversion rate for "how long wiring takes." If the kit's one-time cost is less than the calendar you would burn recreating screens, schema, auth/billing, and an agent-readable layout, buy. If not, keep the free SDK and schedule those four pieces as explicit tickets so they do not hide inside "UI polish." Checkout hesitation ends when you stop comparing catalogs and start comparing weeks. The free SDK wins on components. The paid kit wins when the product spine is the thing you were about to invent anyway. ## Sources - [OTF pricing](https://otf-kit.dev/pricing) — free SDK vs paid kits and landing templates; one-time commercial terms (verified live 2026-09-18). - [OTF Fitness Kit](https://otf-kit.dev/templates/fitness-kit) — concrete full-stack kit preview and stack notes used as the worked example (verified live 2026-09-18). - [Price your first paid tier like a promise you can keep shipping](/blog/pricing-first-tier-ai-built-app) — adjacent BOFU on pricing the promise after you own a product spine (distinct from this checkout payback test). - [Choose a starter kit without a rewrite](/blog/choose-starter-kit-without-rewrite) — general kit selection checks when you are not yet at OTF checkout.