Selling SDKs in the era of many Claudes (Interview)

Summary of Selling SDKs in the era of many Claudes (Interview)

by Changelog Media

1h 50m•February 19, 2026
Listen to Episode

Overview of Selling SDKs in the era of many Claudes (Interview)

This episode of The Changelog features Steve Ruiz (tldraw). Steve explains how tldraw grew from a free whiteboard demo into a commercial SDK business, how he’s adapting licensing and go-to-market in the AI era, and what changes agentic/LLM-driven tooling introduces for product, engineering and sales. The conversation covers licensing choices, pricing experiments, operational automation, internal AI tooling, performance engineering, and early experiments with AI agents embedded into the canvas.

Key takeaways

  • SDK distribution (tldraw via NPM) is a different business than SaaS: higher margins, fewer operational burdens, but harder to capture and convert adoption without thoughtful licensing and sales motion.
  • Licensing matters. tldraw moved from permissive (MIT/Apache) to source-available/commercial models to capture value while still enabling developer experimentation.
  • Early strategy: validate demand with very generous/perpetual licenses, then iterate license mechanics (watermark → watermark+tracking → production license key) to discover users and convert.
  • Pricing is learned via negotiation. Personal, bespoke deals early on are crucial to discover true value; later you can productize repeating deal patterns.
  • Internal tooling + LLMs are a meaningful productivity multiplier for small teams: automated PR/release-note generation, CRM summaries, meeting-note syntheses, and developer agent workflows.
  • Agentic features integrated into a collaborative canvas (spatial AIs / "fairies") are already useful—especially in education and collaborative design workflows.
  • Performance and UX optimizations (e.g., binary encodings, moving overlays to canvas, eliminating costly lodash patterns) are necessary at scale and improve perceived product quality.
  • SDKs enable sovereignty/self-hosting use cases (data access, custom features, privacy) that SaaS providers may not satisfy—this is a driver for adoption in the AI era.

Topics discussed

Business & go-to-market

  • tldraw started as a demo/app (tldraw.com) that doubled as a dog-fooding surface for the SDK.
  • Distribution: tldraw is an NPM package (source-available, non-permissive license adapted from Microsoft-style model).
  • Licensing evolution:
    • v1: MIT/Apache public versions while experimenting.
    • v2: Non-commercial / restrictive license for production use.
    • v3: Free production use with a visible “made with tldraw” watermark so they could detect usage.
    • Current: production requires a license key; free keys for hobby/non-commercial projects and 100-day trials for evaluation.
  • Early revenue: nearly $1M in the first year under simple licensing; company approaching break-even with ~20 people.
  • Sales approach: 100% inbound initially; negotiated bespoke deals to learn pricing and customer value (example offers up to $500k/yr for certain enterprise use cases).
  • Pricing lessons: charge by application/use-case rather than company size; limit license scope to an app/team to make deals viable for large orgs.

Product & engineering

  • SDK vs self-hosted vs SaaS distinctions:
    • SDK = engine for third-party apps; expects to be extended.
    • Self-hosted product = full app you can run; not necessarily architected for extension.
    • SaaS = hosted product; convenience vs sovereignty tradeoffs.
  • Technical optimizations:
    • Replaced heavy Lodash set comparisons to reduce allocations.
    • Switched draw shape encodings from JSON objects to compact binary (e.g., 16-bit floats) for space/time improvements.
    • Moved overlays and indicators from DOM/SVG into Canvas render layers to cut rendering costs and improve frame rates.
    • Culling and hover-check optimizations to reduce work during camera pans (e.g., skip hover checks while panning to halve expensive frames).
  • Developer experience: tldraw.com is the demo, tldraw.dev houses SDK docs and starter kits (multiplayer, agent integration, image-workflow/starter kits).

AI, agents & internal tooling

  • Steve runs many agents internally: examples include automated release-note generation (Mac mini job that summarizes PRs into release notes), CRM/meeting-note summarization, and internal BI helpers.
  • Agents change the developer/product workflow: code production is faster, but product alignment, contribution management, and positioning become harder.
  • Agentic collaboration: experiments with spatial AI “fairies” in the canvas — teams + AIs working together (Steve: “14 people + 42 AIs — and it just works”).
  • Real-world driver: companies want data sovereignty and richer context for internal agents—SaaS APIs often limit the context agents need (e.g., Notion not exposing document history via API).
  • Internal tools are an immediately valuable area for applying LLMs and agents.

Notable quotes / insights

  • “It’s weird and hard and feels very new and exciting.” — on running a company in the AI/agent era.
  • “SDK is like the concentrate — you add the water yourself.” — analogy for SDK vs SaaS.
  • “I don’t know what your security is… I’m not involved in that problem.” — highlighting how SDKs shift operational risk to customers.
  • “We can publish docs every time we land a PR… that’s the type of commitment I would never have made before.” — using automation to change what’s feasible.
  • “14 people, 42 AIs. I’ve never been on anything even close to that.” — describing multi-user + AI collaboration in the canvas.

Practical advice / action items

  • If you’re building an SDK:
    • Treat licensing as product/market discovery: start generous to validate demand, then iterate to capture value.
    • Provide easy developer onboarding (NPM distribution + public demo) and starter kits to reduce friction for integrators.
    • Collect lightweight signals of adoption (watermarked assets, license-key usage) to find and engage potential customers.
    • Negotiate early deals manually to learn pricing and value — then productize common patterns.
    • Consider pricing per application/feature scope rather than per-company size to enable adoption within large organizations.
  • If you’re a small engineering org:
    • Use LLMs/agents to automate repetitive synthesis tasks (PR/release notes, meeting summaries, CRM analysis).
    • Build internal tools for intelligence extraction—these are high leverage and relatively low risk.
  • If you want to try AI + canvas interactions:
    • Try tldraw agent starter kit (search tldraw agent starter kit or npm create tldraw) or visit tldraw.com and tldraw.dev to experiment with demos/starter kits.

Where to try / resources mentioned

  • tldraw (demo & dogfooding site): tldraw.com
  • SDK docs and starter kits: tldraw.dev (agent starter kit, multiplayer starter kits, etc.)
  • Follow Steve Ruiz on X (Twitter): @steveruiz (as mentioned)
  • Look for tldraw agent starter kit demo and potential “fairies” demo site soon (fairies.tldraw.com / related starter kits)

Final notes

This episode is a useful case study in how developer-focused products can become viable businesses in the new AI era, and how strategy (licensing, distribution, manual-to-automated sales motions, and internal agent tooling) evolves when AI both speeds engineering and complicates product/market alignment. If you care about building or buying advanced front-end infrastructure (whiteboards, editors, grids, maps), Steve’s practical lessons on licensing, adoption signals, and negotiation are especially relevant.