What the developer does
Configure your product in context
The developer starts from a prepared system, follows a scenario, changes the live architecture, and retries failed checks until the product behaves as required.
For DevRel, developer education, and product teams
Build a lab that ends with your product running.
We build a working architecture around your infrastructure product, write the guided scenario, and grade every step against the live containers. Developers finish with your product configured and serving its intended role.
A scoped engagement for one complete, reusable lab
vendor-lab / running locallyvalidated
demo app
your product
live service
product container is healthypass
application reaches product endpointpass
scenario-specific state is presentpass
roadmap complete3 / 3
One lab can do several jobs for your developer program.
The same artifact can sit beside a quickstart, anchor a workshop, support onboarding, and give a launch campaign something concrete to ask developers to finish.
What your team provides
Product expertise and technical review
You explain the useful outcome, the setup that matters, and the mistakes worth teaching. We turn that knowledge into the scenario, topology, roadmap, validators, and public page.
product briefvendor
lab implementationTorollo
accuracy reviewtogether
Runtime
No sandbox fleet to operate
Torollo runs through the developer’s Docker daemon. You do not provision a cloud environment or pay for compute each time the lab starts.
Trust
Sponsorship stays visible
The catalogue and lab page always identify vendor content. Developers can distinguish a commissioned Vendor Lab from Torollo’s independent roadmaps.
Distribution
Reuse the finished artifact
Link the lab from product documentation, onboarding material, workshops, and events. The founding engagement also includes a joint mini-launch.
Put the lab wherever developers already meet your product.
Each placement uses the same underlying roadmap. The surrounding introduction and call to action can change without rebuilding the lab.
Use it in
Documentation
Place a complete working example next to the conceptual guide or quickstart. The developer can inspect the surrounding services instead of running one isolated command.
Use it in
Onboarding
Give new users one bounded product outcome, with checks that confirm the setup works before they move to their own project.
Use it in
Workshops
Use the same scenario for a live session. Every participant runs an independent copy on their own machine and can continue after the session ends.
Use it in
Events and launches
Give a conference talk or release campaign a technical follow-up that remains useful after the announcement is over.
How the engagement works
From product brief to released lab
Torollo owns the implementation. Your team makes the product decisions and reviews the technical result.
Choose the useful first outcome
We start with one task a developer should be able to finish with your product. You bring the product knowledge. We shape it into a scenario with a clear beginning, failure state, and working end state.
output: scenario brief
Build the surrounding architecture
Your product runs next to the services it actually depends on: an application, database, proxy, queue, or network boundary. If Torollo needs a new node for the lab, that work is included in the founding engagement.
output: executable topology
Write the roadmap and checks
We author the instructions, hints, and declarative validators. Checks inspect the running containers through network probes, service state, HTTP responses, SQL assertions, or other observable state the scenario requires.
output: guided, auto-graded lab
Review, publish, and reuse
Your team reviews technical accuracy. The finished lab gets a co-branded page, a clear Vendor Lab label, and a joint mini-launch. You can link it from docs, onboarding, workshops, and event material.
output: released vendor lab
A completed vendor lab means the developer configured your product inside a live architecture and every required check observed the expected state.
Founding Vendor Lab
A defined engagement with a finished deliverable.
Co-designed scenario
One concrete product outcome, framed around the architecture and failure state that make it worth learning.
Complete roadmap
The full sequence of instructions and hints, written for a developer encountering the product for the first time.
Deterministic validation
Checks run against the live containers. A learner completes the lab only when the required state is observable.
Co-branded page
A co-branded destination you can use from documentation, onboarding, workshops, and launch material.
60 days of corrections
Corrective maintenance is included for 60 days after release, within the founding engagement timebox.
Founding price
$2,500 to $4,000
One product. One complete lab.
The price includes the co-designed scenario, complete roadmap, automated validation, co-branded page, 60 days of corrective maintenance, and the mini-launch. If your product requires a Torollo node that does not exist yet, building that node is included.
Send us your product and use caseBring the product. Leave with a finished lab.
Tell us what the product does, the developer outcome you care about, and where you want to use the lab. We will reply with the questions needed to scope the scenario.
Talk to us at othmane@torollo.app