The Honest Economics of Free SDKs: Why We Give Away 240+ MIT Components

You'd be right to be skeptical. A free SDK with 240+ MIT-licensed components across web and React Native on npm (150+ web and 85+ native), plus a paid tier that wraps them — that's either a bait-and-switch with a rug-pull scheduled for next quarter, or a generous bet on distribution. It's the second one. Here's why the line between free and paid sits where it does, and why we think moving it would be a worse business.

What the free SDK actually gives you

Three packages, one mental model.

npm install @otfdashkit/ui @otfdashkit/ui-native @otfdashkit/tokens

That's the entire install. ui for web, ui-native for iOS and Android, tokens for the theme primitives. Related component names and shared tokens help maintain a recognizable design system; web and React Native packages still use platform-specific props and rendering.

import { Button, Card, TextField } from "@otfdashkit/ui"

export function Signup() {
  return (
    <Card>
      <TextField label="Email" type="email" />
      <Button intent="primary">Create account</Button>
    </Card>
  )
}

The same file works on web. Swap the import to @otfdashkit/ui-native, the same JSX renders on iOS and Android. No fork, no platform-specific component name, no "this prop only exists on web." Tokens flip one theme across web and mobile, so the component is visually identical everywhere.

The SDK is MIT. Fork it, vendor it, ship it inside a private monorepo — all fine. We don't gate components behind a license check, a telemetry ping, or a build-time flag. The components are the floor, not the funnel.

What the paid kits actually buy

Components are atoms. Kits are buildings. The line isn't generosity — it's where the work is.

A full-stack kit is the same components, wired together with the boring stuff that takes weeks to get right:

• Auth (signup, login, password reset, sessions, OAuth)
• Product billing (not included in SaaS Dashboard; add Checkout and a webhook through the documented customization path if your app needs it)
• Database schema and migrations
• Production deploy (a Cloudflare Workers script that can attach your custom domain with TLS, plus a Dockerfile for any container host)
• AI-tool configs (CLAUDE.md, .cursorrules, 20+ task prompts under ai/prompts/)
• A 24-item design checklist enforced by a script before the kit ships

That's the SaaS Dashboard kit. The Fitness kit is the same shape for mobile-first apps; Booking is the same shape for scheduling. Each one is $99. The Everything Bundle is $149.

// illustrative routes for an app you extend; product billing is not shipped in the kit
app.post("/api/billing/webhook", verifyStripeSignature)
app.post("/api/auth/login", rateLimit({ window: "15m", max: 5 }))
app.post("/api/auth/signup", createUser, sendVerificationEmail)
app.get("/api/me", requireSession, getCurrentUser)

This is illustrative server code, not a file shipped in the SaaS Dashboard kit. The kit includes authentication and database foundations; its customization guide documents how to add Checkout and a webhook. Any billing routes you need are code you implement and test in your own app.

12 production screens. Login and database wired.

The SaaS Dashboard Kit includes login, a database, and a working dashboard. Live demo at saas.otf-kit.dev.

See the live demo

Where the line sits, and why it doesn't move

The honest line: atoms free, application foundations paid. Product billing is a separate implementation.

Components are commoditized. A Button is a Button. The interesting work is the integration — the auth state machine, database schema and migrations, and the deploy script that puts the app on a custom domain in your Cloudflare zone, with Cloudflare issuing the certificate. If your app needs Stripe, implement its webhook and subscription logic separately.

Free SDK earns the right to charge for the kit in three concrete ways:

1. Distribution. A package on npm gets installed. A landing page gets bookmarked. Distribution compounds — every install is a future kit sale that didn't need an ad.
2. Trust. Shipping 240+ components under MIT—150+ web and 85+ native—and maintaining them openly is a credible signal. It's hard to fake. The components stay free because moving them would destroy the trust that funds the paid tier.
3. Onboarding cost. A developer who already wrote their prototype with the free SDK buys the kit at the moment they hit production. That's a natural upgrade path, not a forced one.

The line moves the day we change the SDK license. It doesn't.

What "free forever" means, concretely

Three guarantees baked into how the SDK is shipped:

• New components ship free. We're not gating future work behind a paid plan to drive upgrades.
• The license doesn't change. MIT today, MIT tomorrow.
• No telemetry, no license check, no "free for non-commercial use." The npm install works the same in a hobby project and a Series B startup.

The line is stable because moving it would be the short-term-revenue-maximizing move that kills the long-term business. A bait-and-switch works once. A credible free tier compounds.

What this gets you, day to day

The developer flow looks like this:

1. Install the free SDK. Build a prototype on Saturday. The components are MIT — no anxiety about the rug-pull.
2. Hit production. Real auth, your database, and a deploy path. Buy the kit; add product billing separately if you need it.
3. The kit uses the same components. No re-learning. No "we open-sourced a worse version of what you're using."
4. Ship with the deploy script that comes in the kit — scripts/deploy-worker.sh deploys the web build to Cloudflare Workers and, pointed at a domain on a Cloudflare zone you own, attaches it while Cloudflare issues the TLS certificate. Mobile builds run separately through EAS.

That script isn't a free feature. It ties the build, the hosting and your custom domain together. It's expensive to maintain, and it's the part you actually need the moment you stop prototyping. The design checklist is the same kind of thing — it's a script that runs before the kit ships, so the 24 items that usually bite you in week six are already handled.

The alternative, and why we didn't pick it

Cursor, Lovable, Bolt, v0 — they all have a similar shape: free preview, paid agent, locked-in flow. The bait is a screenshot of a generated app. The lock is everything you can't take with you when you leave.

We picked the opposite shape. The components are MIT and leave with you. The kit is paid because it packages the application foundations, OAuth setup, and TLS/deployment path. If your app uses Stripe, the payment integration is an implementation you add and maintain separately.

The same principle applies in reverse to the alternatives: their free tier is the demo. Our free tier is the production primitive. Different bets, different lines. The 20 landing templates at $9 each sit on a third axis — page-shaped, not full-stack — and they exist because shipping a marketing page shouldn't require a full-stack kit.

The honest answer to "why free?"

Not because we're generous. Because the components are the right thing to give away — they're commoditized, they're the trust-building surface, and they're the distribution channel for the kit. Charging for them would mean charging for the wrong thing.

The kit is paid because the kit is the building: authentication, database, deploy, AI configs, and the design checklist. Product billing is not included; the guide shows how to add it. The line between "free forever" and "paid" sits exactly there, and it's a stable line.

If you're reading this and you're still skeptical: good. The SDK is on npm. Install it. Ship a prototype. The free tier is what we say it is. When you hit the wall where wiring matters, the kit is there — built from the same components you already know.

Sources

• OTF component catalog — lists the current web and mobile component catalogs; checked 16 October 2026.
• OTF web component stories — interactive web component documentation; checked 16 October 2026.
• OTF React Native showcase — live native component preview; checked 16 October 2026.

Related guides

• A shared codebase across platforms — see where reusable structure helps and where platform differences remain.
• Design systems as agent context — keep conventions visible to coding agents.

OTF SaaS Dashboard Kit

Ship the product, not the setup.

• 12 production screens — auth, team, analytics, and settings
• Login and a real database are wired in
• AI configs pre-tuned so your agent extends instead of regenerates

See the live demoEverything Bundle — $149