Your API, taught personallyto every developer who signs up.
We compile your docs into a living, executable onramp. Different for every developer. Running before your first call with us.
Compiled, run end to end, checked for errors, and reviewed by a human before any developer sees it. The terminal on this page is that pipeline running, live.
Most developers decide in their first session whether your API ships or slips.
Ten developers open your docs.
Every one of them wants to ship.
Illustrative and directional, not a measured Atelo figure. Independent benchmarks put the share of new signups reaching activation at roughly 20 to 40 percent (OpenView Product Benchmarks 2022; Userpilot 2024). Lack of documentation is the number one obstacle developers name to using an API (Postman State of the API 2023).
Same docs.A different course for every developer.
Has integrated APIs before
- 01skippedAuth and your first callthey proved this in the three signup questions
- 02coreCreating and capturing a payment
- 03focus areaWebhook signature verificationthe edge case most integrations get wrong
- 04focus areaIdempotency keys under retry
- 05stretchReplay-attack drills on your webhook endpoint
All compiled before anyone signs up. They pick, they open, they build.
Illustrative preview of a generic payments API, not a real customer’s course.
Not request/response? The report says exactly what compiles today.
At signup a developer answers three quick questions. Those answers pick their course, the way you just did.
What lands on your desk.
Three artifacts. Every one, before you ever get on a call.
Request and response examples present on every operation.
1 operation documents no error responses at all; the first 4xx a developer meets will be undocumented behavior.
GET /emailsEvery finding is a fact about the spec, not a style opinion. The onramp compiled beside this report teaches exactly what your docs document, faithfully.
- 01Auth and your first send
- 02The email object and its states
- 03Idempotent retries with Idempotency-Key
- 04Listing and paginating sent mail
- 05Retrieving a delivery by id
Illustrative shape. Your own developers fill it in from day one.
Docs analytics see clicks. A wrong prediction sees a wrong mental model, before it reaches production.
Attributed into your analytics, not trapped in ours. Raw event export included.
Stripe, Box, Adyen, Twilio: we pointed the compiler at their public API docs and it read every operation, example, and error path, mechanically.
A model can draft a course. It cannot run one. Every lesson here executed before you saw it.
A concrete one: Stripe’s 587-operation spec carries a response example on every call, and zero per-operation error codes, every failure bucketed under one default response. The compiler reports the fact, checkable against the document. It does not do opinions. Yours takes 48 hours.
Send your docs. The report is free either way.
Ship a change to your API.The onramp rewrites itself.
Your docs are never finished, so the course never is either. When your API moves, Atelo recompiles only the lessons that touch the change, re-runs them end to end, and shows you the diff. It reaches a developer only after you approve it.
A change to the Acme Mail API is detected: the send endpoint moves to version two and now requires an idempotency key. The compiler flags 2 of 24 lessons that reference that call, rewrites them, and presents the code diff for review. On approval, the lessons are recompiled, re-run end to end, and published to every developer in about four minutes with no engineer involved.
Every other onboarding course is a photograph, frozen the day it shipped. Yours updates itself the moment your API does, and never without your sign off.
And developers who already finished get told what changed, with a five minute lesson, before your change breaks their integration.
Do the math.
Your funnel, your numbers. The one figure we model is the one we bill on, so we only get paid when it is real.
Move these to match your own funnel.
One point of activation, on your funnel, per year. Pure arithmetic; none of it is ours.
Takes your 30% to 33%. Two to four points is the band we underwrite year one against. Your pilot measures your own number.
Incremental revenue at a 3-point lift. We bill on the number your analytics measure, never this slider.
Where these numbers come from
The slider is in percentage points, not relative percent. Moving activation from 30% to 33% is +3 points, a 10% relative gain, which the experimentation literature treats as a large, real win.
Baseline first: a survey of 500+ companies puts median activation at 25% (30% for SaaS, 33% for B2B), and developer funnels concentrate in the 20 to 40% band. Postman’s State of the API has found for five years running that roughly half of developers name documentation the number one obstacle to consuming an API, which is why the onramp is usually the highest-leverage fix.
The $600 default decomposes as roughly 15% of activated developers converting at about $4,000 first-year account value, mid-range for usage-priced APIs: SendGrid’s ARPA at IPO was about $2,000, Stripe averages about $3,900 per active business.
Published results for serious onboarding improvements cluster between +2 and +12 points: a B2B case moved 30-day activation from 37% to 49%, +12 points (vendor-published); another reported a 20% relative gain, roughly +8 points. In-app guidance vendors claim up to +22; we treat vendor claims as a ceiling, not a median. And 70 to 90% of controlled experiments at mature companies move nothing at all (Kohavi, ex-Microsoft and Airbnb), so we default the slider to +3 and cap it at +8, labeling 7 and up top decile.
Teams starting from a low baseline with no guided onboarding today can land above the cap. We would rather you find that out in your own data than in our calculator.
We price year one on proof, not promises.
Ninety days, head to head with your current docs, five success bars agreed in writing. Miss them and there is no year one to pay for.
Step zero is free: a docs URL gets you the report and a running course in 48 hours. The $15k starts only if it earns ninety days.
90 days. Credited in full toward year one. Here is everything you get:
- A finished course for every kind of developer who signs up, ready before they arrive so no one waits
- Hosted on your subdomain; each developer answers three quick questions and opens the right course instantly
- Five success bars agreed in writing day one, measured in your analytics and ours. High-volume funnels add a hard activation A/B
- A funnel readout and struggle heatmap on your desk by day 30
- Your team's admin view from day one: who is stuck, on what, by skill
- Your docs change mid-pilot, we recompile the affected modules
- Security brief, and our engineer on a shared channel
- Our standard DPA, signed from day one
A purchase order, not an RFP: credited in full toward year one the moment you continue.
Five at a time, because each one gets our engineer in your channel. When the lift clears the bars, we will ask to name you as the first case study.
Ninety days because activation cohorts need time to mature; a shorter read is noise.
Growth$60k a year
The onramp, kept alive. Unlocked when the 90 days clear the success bars we agreed, in your analytics.
- Changelog regeneration, approval workspace, version pinning
- Full analytics: funnel, heatmap, and sales-ready account signals
- An AI assistant grounded on your docs, citing the section it answers from
- Quarterly persona refresh, 5-business-day freshness SLA
- Raw event export included, your numbers are yours
Enterprise$120k to $250k a year
For multi-product platforms and procurement-grade requirements.
- Multi-product, SSO and DPA
- Identity federation, custom personas
- 48-hour priority SLA
- Dedicated review workspace, co-marketing rights
Priced to be the easiest yes in your budget. Ninety days later the scenario above is your measured number, not our model.
Bought separately, a lab platform, a customer academy, and activation analytics run well past this combined. None of the three builds a different course per developer.
One honest floor: under roughly 500 developer signups a month the data runs thin and the head-to-head test is off the table. We will tell you what ninety days can and cannot prove before you pay.
Send your docs. The ninety days only start if the free look earns them.
Send your docs.Within 48 hours you get the report and your first course, running.
Company, work email, and a docs URL. That is all we need to start.
Where your docs go. Never used to train models. No repo access, no production credentials, ever. DPA signed from day one. Read the security briefNo deck. No discovery call. The deliverable is the meeting.
The report is yours either way. Clean or damning, it is the most useful document your docs team gets this quarter.
Prefer to read first? See the security brief.