Which events get recorded. Whether the codebase can show two versions of a screen to two groups of users. How fast the page renders on a mid-range phone.

Those are engineering choices, and they decide how much a growth team can learn after launch. This piece covers what’s worth building in while you still have the chance.

Why Conversion Work Starts in the Codebase

A conversion is any action you want a visitor to take: creating an account, booking a demo, finishing a purchase, upgrading a plan. Improving the rate means finding where people stall and testing changes that help them get through.

That process needs three things from the software. It needs reliable data about what users do. It needs a way to change the experience for some users and not others. And it needs pages that don’t get in the way with slow loads, broken forms or confusing errors.

If any of those are missing, the work turns into guesswork. Somebody redesigns the pricing page because it “feels off,” nobody can say whether it helped, and six weeks go by.

None of this requires a big analytics budget at the start. It mostly requires planning for measurement the same way you’d plan for authentication or logging.

Agree on What Counts as a Conversion

Before anyone writes tracking code, get product, marketing and engineering in a room and list the actions that matter. Keep it short. A B2B tool might care about trial sign-ups, completed onboarding and paid upgrades. An ecommerce build cares about add-to-cart, checkout started and order placed.

Then name the events consistently. Pick a convention (say, all lowercase snake_case) and stick to it, so signup_completed doesn’t sit next to SignUp and user-registered in the same report. That sounds fussy. It saves hours of cleanup later.

Your analytics tool may also shape the plan. In Google Analytics 4, any event can be flagged as a key event, and Google’s help documentation on marking events as key events notes that a standard property can flag up to 30 of them. The same page says marking an event affects reports from the time it’s created and doesn’t change historic data.

That last detail is the real argument for doing this before launch. If the event isn’t firing on day one, you can’t go back and recover what happened on day one.

Events Worth Recording Beyond the Final Action

The final conversion tells you how many people made it. The steps before it tell you where everyone else stopped. So record the in-between moments too: form started, form submitted, validation error shown, payment step reached.

Error events get skipped a lot, and they’re often the most useful. A spike in failed submissions on one field usually points to something specific you can fix.

Build Experiments Into the Architecture

Testing a change properly means showing version A to one group and version B to another, then comparing results. You can bolt this on later with a client-side testing script, and plenty of teams do. Building support into the app itself tends to be cleaner, especially for logged-in experiences, pricing logic or anything rendered on the server.

Feature flags are the usual way to do it. Pete Hodgson’s long-running article on feature toggles and their categories describes experiment toggles as the type used for A/B and multivariate testing, where each user is placed in a cohort and consistently routed down the same code path. Consistency matters here. If a returning user sees version A on Monday and version B on Wednesday, the results get muddy fast.

Hodgson also makes a point teams tend to learn the hard way: flags carry a cost, and a team must be proactive in removing ones that are no longer needed. His suggestions include adding a removal task to the backlog when a flag is created and setting expiration dates. An app full of dead experiment branches is harder to test, harder to debug and harder for new developers to read.

A few practical habits help:

  • Store which variant each user saw, and attach it to their conversion events
  • Keep experiment logic in one place instead of scattered if statements
  • Agree on who’s allowed to turn an experiment on or off in production
  • Delete the losing branch once a decision is made

Who Runs the Testing Program After Launch

Building the plumbing is one job. Using it well every month is another, and it’s where a lot of software projects lose momentum. The developers move on to the next feature, marketing doesn’t have the time or the analytics background to design tests, and the experiment framework sits unused.

Someone has to own the cycle: review the funnel data, form a hypothesis, decide what to test next, check whether results are trustworthy, then hand winning changes back to engineering. Some companies hire for this in-house. Others bring in outside conversion rate optimization services that typically cover conversion audits, user behavior research, a ranked testing roadmap and experiment reporting, then work alongside the development team that maintains the code.

Either way, decide before launch who that person or team will be. If it’s an outside partner, arrange appropriate, role-based access to analytics and experimentation tools early, and agree on how test changes move through code review and deployment. A test that sits in a ticket queue for three weeks isn’t much of a test.

Traffic Volume Changes What You Can Test

Here’s the part that frustrates founders. A/B testing needs enough conversions in each version to tell a real difference from random noise. A new app with a few dozen sign-ups a month usually can’t run a meaningful split test on a single button color. The numbers just won’t settle.

That doesn’t make the work pointless for smaller products. It changes the method. Lower-volume apps often get more from qualitative research (session recordings, user interviews, support tickets) and from fixing obvious friction, then comparing before-and-after numbers over a set period.

Higher-traffic products can test more often and test smaller changes. Even then, keep experiments focused, account for overlapping tests and allow enough time and conversions to evaluate results reliably.

The Friction Developers Control

Some conversion problems are copy or design problems. Plenty are engineering problems that look like design problems.

Page speed is the obvious one. A sign-up page that takes a long time to become usable on a phone will lose some visitors before they see the form. Set a performance budget early and check it in your build pipeline, so a heavy new script or an oversized hero image gets caught before it ships.

Forms come next. Every required field asks the user for a little more effort, so question each one. Support browser autofill with the correct autocomplete attributes, use the right input types so phones show the right keyboard, and validate inline instead of wiping the whole form after a failed submit.

Error messages deserve more attention than they get. “Something went wrong” gives a user nothing to act on. A message that says which field failed and why can keep someone moving instead of closing the tab.

And then there’s the stuff nobody notices in testing because the team always uses fast laptops on office Wi-Fi. Try the main flows on an older phone over a throttled connection now and then. It’s humbling.

Consent banners, ad blockers and privacy settings in browsers all affect how much behavior your analytics can see. Depending on where your users are, privacy rules in places such as the European Union may require consent before certain tracking runs.

Two things follow from that. Consent choices, browser restrictions and tracking errors can create gaps or distortions in analytics data. Treat reported activity as a measured sample of user behavior rather than a perfect record of every interaction.

And your consent setup needs to be part of the build, not a plugin someone adds the week before launch. Talk to whoever handles legal and compliance for your company about what applies to you.

If you run experiments server-side, check how variant assignments and user identifiers are stored, too. That data is often more sensitive than people assume.

A Pre-Launch Checklist for Product Teams

Run through this before the app goes live:

  • Conversion actions are listed and agreed on by product, marketing and engineering
  • Event names follow one convention and are documented somewhere the whole team can find
  • Key events are marked in your analytics tool, along with the steps and errors leading up to them
  • A feature flag system can assign users to consistent experiment groups
  • Variant assignments are recorded alongside conversion events
  • A performance budget is set and checked during builds
  • Forms support autofill, use correct input types and show specific error messages
  • Consent handling is built in and reviewed
  • Someone owns the testing program after launch, with access to data and deployment

Not every item needs to be perfect on day one. But agreeing on conversions and setting up reliable tracking early matters, because data that was never collected generally cannot be recovered later.

If Your App Is Already Live

Plenty of teams read a list like this after launch. That’s fine. Start with an audit of what your analytics records today, compare it against the conversion actions you care about, and fill the biggest gaps. Then look at your funnel for the step with the sharpest drop and spend time there before touching anything else.

The codebase you already have can probably support more testing than you think. It just needs someone to treat measurement as part of the product instead of an afterthought.