Seven launch notes: time-to-first-call, docs, a narrow stills-and-PDF wedge (we do render PDF pages), public pricing, and distribution. PDF is in the catalog; video is not.
Overview
Launching jsontoimg — a JSON-to-image API — taught me that the API itself is the easy part. The renderer took weeks; everything around it took months. This post collects the seven lessons that actually moved the needle: time-to-first-call, docs as product, picking a narrow wedge, transparent pricing, distribution, building in public, and market timing. If you’re launching a developer tool, steal the parts that fit.
Lesson 1: The API Is One-Third of the Product
The most repeated line in indie founder launch threads is also the truest: *”the product is one-third of the product”* (Indie Hackers, 5 Lessons Learned from Launching my first SaaS). As a developer, shipping code is the comfortable part. The hard part is everything users touch before, during, and after the first request:
- The docs — can a stranger understand the API in one page?
- The signup flow — how many clicks between landing and API key?
- The error messages — do failures teach or confuse?
- The pricing page — is the cost obvious or hidden behind “Contact sales”?
- The first response — is it fast enough to feel magical?
jsontoimg’s rendering engine was the smallest slice of the build. Templates, webhooks, batch endpoints, transparent status on every render, and clear errors took far more design effort than the renderer itself. Developers don’t fall in love with your architecture; they fall in love with the *experience* of using it.
Lesson 2: Time-to-First-Call Is the Metric That Matters
Postman calls time-to-first-call (TTFC) “the most important API metric,” and the data backs it up: developers using a pre-built collection made a successful first call 1.7× to 56× faster than those starting from scratch (Postman Blog). Fern’s developer onboarding research puts concrete numbers on the bar: under two minutes from docs landing to first successful call puts an API in the top tier — anything over ten minutes signals major onboarding friction (Fern).
What that meant for jsontoimg:
- The homepage leads with a complete, copy-pasteable request — no signup wall before you see the shape of the API.
- Every tutorial starts from a working example, not from theory.
- A real API key is issued in seconds after signup, with a generous free tier so the first call costs nothing.
The goal was boring on purpose: a developer lands, pastes one curl, and gets an image back before their coffee cools.
curl -X POST "https://app.jsontoimg.com/api/v1/render?wait=60" \
-H "Authorization: Bearer $JSONTOIMG_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"template": "og-card",
"format": "png",
"layers": {
"title": { "text": "First image in 30 seconds" },
"subtitle": { "text": "JSON in, image out" }
}
}'Lesson 3: Docs Are the Product — Write Them Like Code
API product marketers are unanimous on the launch checklist: documentation live and polished on day one, a single-page quick-start, and showcase projects developers can copy (Stackmatix). Kong’s API product guide adds the important nuance: don’t stop at the reference — organize docs around use cases and workflows, so developers can move from setup to production quickly (Kong).
That’s exactly why jsontoimg ships a dedicated page for every use case instead of one giant reference:
- Auto-generate Open Graph images at scale
- Product banners for thousands of SKUs
- Certificate generation
- A/B testing ad creatives
Each page answers one question: *”I have this problem — how do I solve it with jsontoimg?”* A developer who finds their exact scenario in the docs is a developer who stays.
Lesson 4: Pick a Narrow Wedge and Own It
The biggest temptation in a fast-growing market is to become a platform. jsontoimg deliberately stayed a stills-and-PDF API. No video pipeline, no workflow builder. Competitors like APITemplate.io bundle templates, documents, and automation — genuinely powerful, but a much larger surface to learn, maintain, and price.
The indie hacker MVP rule applies: ship one or two features and make them excellent. jsontoimg launched with templates, batch generation, and webhooks. Everything else waited for a user to ask for it. A narrow wedge is also a positioning gift — when a developer asks “what does this do?”, the answer is one sentence: *JSON in, image out.*
Lesson 5: Transparent Pricing Is a Growth Feature
Developers are allergic to “Contact sales.” They want to know the cost before they invest an afternoon integrating. The playbook for developer products is consistent: transparent, usage-based pricing with a free tier when you can afford it (Markepear).
jsontoimg follows the same philosophy:
- Free tier to build and test without a credit card
- Usage-based pricing that scales with actual renders — no platform fees, no seat costs
- Published numbers on the pricing page, because hiding them only delays the conversation
Pricing is part of the developer experience. If the cost math is easy, the decision is easy.
Lesson 6: Launch Is the Start of Distribution, Not the End
A launch is a moment; distribution is a habit. The standard channels still work — Hacker News, Product Hunt, and the relevant subreddits (Stackmatix) — but the compounding channel is building in public (Engineers Codex, 10 Lessons from One-Person Startups). The image-API space has living proof: Jon Yongfook publicly shared ~$52k/month across Bannerbear and Browserbear, both built and marketed in the open.
For jsontoimg, building in public means this blog: the story behind ditching Puppeteer, the use case deep dives, and the honest comparisons. Every post is a distribution asset that keeps working after launch week ends. Ship the product, then ship the story of the product.
Lesson 7: The Market Is Bigger Than It Looks — Stay Focused
The AI-powered image generation tool market is projected to grow from $9.1 billion in 2025 to $272.8 billion by 2035 — a 40.5% CAGR (Market.us). MarketsandMarkets pegs the AI image generator segment alone at $8.7 billion in 2024, reaching $60.8 billion by 2030 (38.2% CAGR) (MarketsandMarkets).
The slice jsontoimg cares about is the deliberately *boring* one: structured, programmatic image generation — OG cards, product banners, certificates, email heroes. Boring is good. It’s predictable, repeatable, and every product team on earth needs it. The temptation is to chase the flashy text-to-image trend; the discipline is to keep solving the boring problem better than anyone.
Key Takeaways
- The API is one-third of the product — docs, onboarding, and pricing decide adoption.
- Time-to-first-call is the metric that matters; aim for under two minutes.
- Organize docs around use cases, not just endpoints.
- Stay stills-and-PDF: a narrow wedge is easier to build, price, and explain.
- Transparent, usage-based pricing with a free tier builds developer trust.
- Launch is the start of distribution — building in public compounds.
- The market is huge; focus on the boring, repeatable slice and own it.
FAQ
What is the hardest part of launching an image generation API?
The API itself is about a third of the work. The editor that produces templates, the docs that get someone to a first call, and metered billing are the other two thirds — and they are what people actually judge.
What onboarding metric matters most for a developer API?
Time-to-first-call. Every minute between signing up and seeing a rendered image is a chance to lose the developer, which is why jsontoimg gives 25 free images with no card.
Why target a narrow wedge instead of an all-in-one platform?
A stills-and-PDF image generation API can be typed, predictable, and cheap per image. Adding video, screenshots, and AI layers widens the surface and blurs the pricing, which is exactly the confusion a dynamic image API should remove.
Does publishing prices actually help growth?
Yes. A published price per image lets a developer finish the build-versus-buy math alone, in the tab they are already in, without booking a call.