A/B Testing — Client-Side & Server-Side
A Bayesian engine tells you the real probability your variant is winning — not a yes/no significance flag — and mSPRT keeps the math valid even if you peek every five minutes. AI writes the variant code from plain English. Conversion Research findings turn into experiments with one click.
Active Experiment
Homepage Hero CTA Button
Variant A has an 85% Bayesian probability of beating control · mSPRT p-value still valid
Your team has opinions about what will convert better. So does your agency. So does every blog post about "best practices." None of them are running on your audience.
How most teams decide
"The CEO thinks the blue button looks better."
"We changed the headline last quarter and signups went up — so we're keeping it."
"Everyone on our team prefers the shorter form."
Survivorship bias. Confounding variables. Gut feel dressed up as strategy.
With A/B Testing
Both variants run simultaneously on real visitors — no time-period confounds, no seasonality bias
Statistical significance tells you when the result is real, not just lucky
The dashboard shows you which variant wins and by how much — then you ship it
Every experiment compounds: small wins stack into double-digit conversion gains over a year
No A/B testing infrastructure to build. No data science team required. Add a snippet, define your variants, and let the SDK handle the rest.
Define your variants, set traffic allocation, and pick your goal — whether that's a button click, a page visit, or a custom conversion event. The dashboard walks you through it in under two minutes.
Drop a single `<script>` tag on your site for client-side experiments, or install the server-side package for full control in Next.js, Node, or any backend framework. No separate A/B testing infrastructure required.
The SDK assigns each visitor to a variant using deterministic FNV-1a hashing — the same browser keeps the same variant across sessions (first-party cookie only, no third-party tracking). Pass a stable user ID into the SDK to make variants consistent across a logged-in user's devices.
Client-side install (copy and paste)
<link rel="preconnect" href="https://js.growthroadmaps.com" crossorigin>
<script src="https://js.growthroadmaps.com/growth.min.js" async></script>
<script>
window.addEventListener('gr:ready', async function() {
window.gr = new GrowthRoadmaps({
projectKey: 'YOUR_PROJECT_KEY',
apiHost: 'https://growthroadmaps.com'
});
await window.gr.init();
var variant = window.gr.getVariant('hero-cta-button', 'control');
if (variant === 'variant-a') {
document.querySelector(".hero-cta").textContent = "Get Started in 60 Seconds";
}
});
</script>Most A/B tools give you a p-value and call it a day. We run four checks behind every experiment so you can stop a test early without fooling yourself, and ship winners with confidence.
A Beta-Binomial model runs 50,000 simulations per result to give you a real "B beats A" probability — not a yes/no significance flag. You see how likely the winner is actually winning, with 95% credible intervals on the lift.
Peek at results whenever you want. Standard A/B tests break if you check early. Ours don't — the mixture sequential probability ratio test produces an always-valid p-value that holds up under continuous monitoring. Once a winner or loser is declared per goal, the decision sticks so the result can't flip back and forth.
For products where the same users come back week after week — streaming, SaaS, two-sided marketplaces — turn this on in A/B settings → Advanced. Each visitor's pre-experiment behaviour becomes a baseline, so the same lift confirms with up to 50% less traffic. Off by default because most e-commerce traffic is one-and-done, and a sparse pre-period can steer the adjustment the wrong way.
A chi-squared check warns you the moment your traffic split looks off (e.g. 47/53 instead of 50/50), so a broken redirect, a misfiring tag, or a targeting bug doesn't quietly pollute your results for two weeks before you notice.
Translation: you can call winners faster, on less traffic, with fewer false positives — and you'll know when something's off before it costs you a quarter of bad decisions.
Most variant tools give you a WYSIWYG that breaks the moment your CSS gets opinionated. Ours hands the job to an AI chat that can read your live page HTML, find the right selectors, and write JS or CSS for you.
Chat in plain English
"Make the hero CTA orange and change the copy to Get started in 60 seconds." The AI proposes the JS/CSS, shows you the diff, and applies it on a click. No CSS specificity wars.
Reads your live page
The chat fetches the actual HTML from your default URL so it picks selectors that exist — not made-up class names. Works on Webflow, WordPress, Shopify, hand-rolled HTML, and React apps.
Editable code, library presets
Drop into the CodeMirror editor and tweak by hand if you want. Toggle jQuery or Bootstrap presets if your site already loads them. Preview the variant on a signed URL before it ships.
AI variant chat
You
Make the pricing toggle default to "Annual" and add a 20% off badge next to it.
AI · proposed change
document.querySelector('[data-billing="annual"]').click();
const t = document.querySelector('.billing-toggle');
const b = document.createElement('span');
b.textContent = 'Save 20%';
b.className = 'badge badge-green';
t.appendChild(b);Marketers get a no-code snippet. Developers get a full server SDK with type safety, edge rendering support, and no client-side flash.
Script tag · No deploy required
Drop a `<script>` tag anywhere on your site. Variant assignment happens in the browser using deterministic hashing. Ideal for marketing sites, landing pages, and teams without backend access.
<link rel="preconnect" href="https://js.growthroadmaps.com" crossorigin>
<script src="https://js.growthroadmaps.com/growth.min.js" async></script>
<script>
window.addEventListener('gr:ready', async function() {
window.gr = new GrowthRoadmaps({
projectKey: 'YOUR_PROJECT_KEY',
apiHost: 'https://growthroadmaps.com'
});
await window.gr.init();
// Variant changes are authored in the dashboard's
// visual editor (or AI variant chat) — no extra code.
});
</script>npm package · Zero client-side flash
Install @growthroadmaps/ab-server and call getVariant() at render time. Visitors get the correct variant from the first byte. A 30-second config poller keeps experiment definitions fresh; exposure events flush every 5 seconds in the background. Zero browser dependencies, runs on Node ≥18 and edge runtimes.
import { ABTestingServer } from "@growthroadmaps/ab-server";
const ab = new ABTestingServer({
serverKey: process.env.AB_SERVER_KEY,
apiHost: "https://growthroadmaps.com",
// 30s config poll, 5s event flush — both tunable
});
await ab.connect();
const variant = ab.getVariant({
experimentId: "checkout-layout",
userId: session.userId,
fallback: "control",
});
// variant === "Variant A" | "control"
return render({ layout: variant });Most teams patchwork a research tool, an A/B tool, an analytics tool, a heatmap tool, and a survey tool. Then they spend half their time copy-pasting between them. We collapsed that loop into one platform.
When a Conversion Research finding turns into a real hypothesis, hit "Move to Testing." We pre-fill the experiment with the issue, the hypothesis, the page URL, and a sample-size estimate based on your baseline conversion rate and minimum detectable effect. The finding stays linked to the experiment, so the result writes back to your research log.
The result analysis pulls per-variant breakdowns from GA4 by device (mobile/desktop/tablet), source (paid social vs organic), new vs returning, and browser — using the custom dimension we map for you. So when an overall flat result is actually a +14% on mobile, you'll see it.
Attach a survey to specific variants, fire it on a delay or on a goal completion, and get qualitative "why" data alongside the conversion lift. Powered by the same survey tool you already use in Growth Roadmaps — no extra integration.
One click on the Compare toggle puts the variant and the control on the same screen — clicks, scroll depth (10% intervals), rage clicks, and dead clicks rendered next to each other, split by device. See exactly which element the winning variant is pulling attention to, and where the losing variant is bleeding visitors. Compare different date ranges too, so you can prove the lift wasn't a seasonal blip.
Scheduling, preview URLs, targeting operators, custom goals, and deterministic bucketing — the load-bearing controls for running real experiments without writing wrapper code.
Set the share of visitors who enter the experiment with a slider — start at 10% on a low-traffic page, ramp to 100% once you trust it. Schedule any variant to start, pause, or resume on a date so launches can sync with a campaign.
QA any variant before it ships using a signed URL with ?_ab_preview=. Share a ?_ab_review= link so stakeholders see the variant without affecting the live split.
Run a test on the exact pages you care about — contains, exact match, starts-with, or regex. No JavaScript required to scope where the experiment fires.
Target by country, device, browser, OS, cookie, or query param — combine rules with AND/OR. Project-wide audience attributes flow into goals and result filters.
Click on a CSS selector, page visit (URL match types), form submit (action URL or selector), engagement, or fire window.gr.track('signup_completed') from your own code. Save goals as project templates.
FNV-1a hash of experiment ID + visitor ID. The same browser keeps the same variant across sessions via a first-party cookie — and stays consistent across devices when you pass a stable user ID (e.g. logged-in account) into the SDK.
A "winning" variant means nothing if the test was broken. Every result page runs through the same seven validity threats from the CRO-Testing playbook — sample size, SRM, novelty effect, multiple comparisons, run length, external history, and selection bias. The first five are scored automatically by the engine; the last two need an operator's eye and an explicit pass/fail before the result counts as shipped.
Use cases
The same Bayesian engine runs under the hood for every business model. What you test — and what counts as a win — depends on your funnel.
DTC ecommerce stores
Test PDP layouts, CTA copy, checkout flow order, and shipping-cost reveal timing — the variants that move add-to-cart and completed-purchase rates.
See A/B testing for DTC ecommerce →
SaaS self-serve products
Run experiments on pricing page copy, trial onboarding steps, upgrade prompts, and feature gates — the tests that close the gap between signup and paid.
See A/B testing for SaaS self-serve →
Lead generation sites
Test form length, trust signals, headline framing, and CTA placement against booked-call or form-submit goals — not just clicks.
See A/B testing for lead generation →
The things people ask before they run their first test.