Product
One system for your website and every experiment on it.
You write pages in the studio. The compiler builds every variant of every page when you publish. The server picks one for each visitor, sends it, and counts what happens next. Each part knows about the others, which is why there's nothing to glue together.
Studio
A studio made for writing pages, not dragging boxes.
Pages and components are TSX, the markup React developers already know, in an editor that understands Mockly. The preview shows any page, in any variant.
Errors as you type. Type checking, autocomplete, and go to definition, with every problem explained in plain words.
A live preview. Desktop, tablet, or phone, with any experiment's variant forced, and outlines that show where experiments are.
Interactive parts. Tabs, menus, calculators, and modals with state, compiled to small scripts that load when they're needed.
Search and rename. Search every file, find and replace, and links that follow a page when it's renamed.
Data from your CMS. JSON fetched when you publish, refreshed on a schedule or by your CMS's webhook.
SEO built in. Titles, descriptions, share images, structured data, a sitemap, and robots.txt, generated on every publish.
Version history
Every publish kept. Compare, preview, and restore.
Each version records exactly what changed. Open any of them to see its pages as visitors got them, then put it back with one click if you need to.
Line by line. What a version changed, compared with the one before, the live site, or your draft.
Its pages, as they were. Styles, fonts, images, and every variant, even files replaced since.
A plan before publishing. Which experiments start, change, or stop, before anything goes live.
Experiments
Experiments are part of the language, not a layer on top.
An <Experiment> wraps the part of a page that changes, with a <Variant> for each version, or varies a single value inline. Because the compiler understands them, it can build every variant ahead of time and catch mistakes before visitors do.
Inline or in blocks. Vary one value in one line, or write whole sections side by side. Two to eight variants, with the weights you choose.
Across pages. Use the same experiment on the home page and the pricing page, and each visitor sees the same variant on both.
Sticky. Each visitor keeps their variant across pages and visits, in a first-party cookie.
Guarded. Misspelled variants are type errors, and a variant that renders exactly like control is flagged when you publish.
In your control. Change the split, pause, restart the results after a fix, or ship the winner to everyone, from the studio.
import { Experiment, Page } from "mockly"; export default function Home() { return ( <Page title="Acme"> <h1>Launch pages that learn</h1> <Experiment name="cta" goal="signup" variants={["control", "green"]}> {(v) => ( <a href="/signup" track="signup" class={v === "green" ? "bg-green-600" : "bg-black"}> {v === "green" ? "Start free trial" : "Get started"} </a> )} </Experiment> </Page> );}
Goals and forms
Count what matters, on the server.
A goal is whatever a page is for: a click, a form sent, a thank-you page reached. Your site's own server records them: thank-you pages without any JavaScript, and clicks with a tiny first-party beacon.
Clicks. Add track="signup" to any link or button.
Forms. A <Form> posts to your site, records its goal, and can send each submission to a webhook.
Thank-you pages. A page can be a goal, counted when it's served: no JavaScript needed, even after a redirect from a checkout or a scheduler.
Side effects. Watch up to five secondary goals. A winner that loses sign-ups says so in its verdict.
import { Page } from "mockly"; // Counted when it's served, with no JavaScript.export default function Thanks() { return ( <Page title="Thanks" goal="signup"> <h1>You're on the list.</h1> </Page> );}<Form name="waitlist" redirect="/thanks"> <input type="email" name="email" aria-label="Email" required /> <button>Join the waitlist</button></Form>- cta-clicktrack="cta-click"/
- waitlist<Form>/
- signupgoal="signup"/thanks
Analytics
Analytics without a tag manager. Or a cookie banner's worth of trackers.
The server that sends your pages counts them. There's no analytics tag for visitors to download, and page views are counted even when JavaScript is blocked.
Traffic. Visitors, page views, sessions, bounce rate, and time on page, over 24 hours to 90 days.
Sources. Referring sites and UTM campaigns, so you know which channels convert.
Pages, countries, devices, and goals. Where visitors go, where they are, what they use, and what they do.
Private by design. No IP addresses stored, no third-party trackers, and bots left out of every count.
Heatmaps
See where visitors click. And how far they scroll.
Turn on a heatmap for one page or every page, and see clicks painted over the page as visitors got it. Pages that don't record one load nothing extra.
Clicks, on the right element. Each click is recorded on the element it landed on, so it lands right at any screen width.
Rage and dead clicks. Quick repeated clicks, and clicks on things that do nothing, show where people get stuck.
Scroll maps. How far down each view got, and where the first screen ends.
For each variant. Compare how visitors used each variant of a test, not only which one converted. Nothing anyone types is recorded.
Statistics
Results you can check any time. Decisions you can defend.
Classic A/B statistics assume you look once, at the end, so checking daily quietly multiplies false winners. Mockly's intervals are confidence sequences: they hold at every look, so stopping as soon as one clears zero is sound.
One verdict. A variant wins, does worse, has no clear winner yet, or needs more data, in plain words.
Several variants, fairly. With more than two, the intervals are adjusted together, so more variants don't mean more false winners.
A broken split, caught. If visitors don't split as the weights say, results are held back and the page says which variant is off.
How long to run. Visitors and days, at your traffic, to detect a 5%, 10%, or 20% lift.
Each visitor counts once, in the variant they saw first.
Checked. Against an independent implementation, and by simulation: under 5% false winners, however often it's checked.
A lift's 95% interval, day by day (example)
Performance
Fast by construction, measured in the field.
Pages are built when you publish, so serving one means picking a variant and sending HTML that's already done. Then Mockly measures how fast it really loaded, in your visitors' browsers.
Almost no JavaScript. Under 1.25 KB on pages without interactive parts, and each page loads only the code for its own.
Real-visitor speed. Page load, first paint, first byte, and layout shift at the 75th percentile, like Core Web Vitals, by page and device.
Page weight. What each page downloads, by HTML, CSS, and JavaScript.
Images, handled. Every image gets resized WebP copies and a srcset, so phones don't download desktop-sized files.
Run your first experiment this week. Build it, test it, ship the winner.
Free to start. No credit card required.