6 minute read
Illuminate Stronger Results
You’d never cook dinner in the dark. The results wouldn’t be digestible. Plus, chopping vegetables would be downright dangerous. Yet, when it comes to preparing A/B tests for the product features your company builds and deploys, “in the dark” is often where you’re forced to operate.
Did all the people in your test sample complete the experiment you served without hesitation? Or, did a handful abandon the page somewhere along the user journey? Without meticulously contextualized data, it’s difficult to truly see the full picture.
Hidden factors can go unnoticed in the shadows of any experiment, leading to blurry data and inaccurate results. If you’re not careful, you could be left fumbling through the darkness, potentially making a poorly-informed product decision. Not ideal.
Inconclusive evidence ruins confidence, false results cloud visions, and it’s a dark place to be. Just the thought of fuzzy data is enough to leave a bad taste in your mouth. Make it a regular occurrence, and it’s more like a general saltiness toward experimentation across your organization.
Not to worry. The experiment lives on. Remind your company why you test like you do, and embrace a better set of practices. There’s a method called trigger testing that can help ensure the data you capture is crisp, accurate, and crystal clear. Make your data count through the brilliance of trigger testing, and rather than launch in the dark, launch in the light.
Highlight Data That Matters With a Hyper-Focused Beam
Trigger testing works by initiating experiments with a specific user action, or trigger. A trigger could be clicking a button or scrolling to the bottom of a webpage. These are actions that go beyond merely launching an app or visiting a page.
The goal of trigger testing is to focus your event capture on the right users. These are the people who actually had an opportunity to be influenced (or not influenced) by your experiment. Let’s say your experiment is at the bottom of the page, but only a small percentage of test groups scroll down far enough to see it. With trigger testing, you can count only the test groups who see the feature in your experiment.
Or, let’s say you’re testing a new checkout experience. If you’re only concerned with what happens after users click the “checkout” button, you wouldn’t want to count all the people who simply saw a shopping cart in your calculations. Instead, you’d want to focus on those who actually clicked “checkout”. Trigger testing helps you hone in.
Think of triggering like a flashlight that switches on the moment a user engages with your experiment, highlighting the data that matters within a relevant timeframe and context. Why is this important? More accurate results mean more happy customers that can’t keep their hands off your digital product. Figure this out, and you can leave your competitors in the dark, tripping forward on missed opportunities.
Turn On the Brilliance of In-App Decision-Making
Proper trigger testing requires the right feature management and experimentation platform. But, buyer beware: not all solutions are advantageous to the trigger tests you desire. As it is with anything, implementation matters. The finer details of software design make technology truly stand out.
What should you look for to execute a flawless trigger test? There’s one aspect that separates some feature flags and experimentation platforms from the rest. It’s the ability to make just-in-time experiment assignments via an in-app decision engine. Platforms that lack this ability require a network round-trip to get an assignment. This leads developers to pre-fetch those assignments at app launch for efficiency.
If you assign users to one side or another of an experiment at launch, you are lumping all users together blindly. This is before they get to the right part of your app where you’d want to trigger their involvement. As a result, you are putting all users in the denominator of your equations, which dilutes and distorts any calculations you perform thereafter. Some might call that “fuzzy math.”
If the platform provides an in-app decision engine, there’s more clarity. The assignments can be made in real-time, only as needed, with no network dependency or performance penalty. Operating this way by default, as Split does, leads developers to do the right thing without specialized training or oversight. Additionally, the in-app decision engine also supports instant updates to your experiments and delivers stronger privacy protection to the end-user.
Spotlighting the Split Difference
Split’s client SDKs all contain an in-app decision engine. The rules you set are evaluated locally and instantaneously right inside your proprietary app. After defining rules in the cloud, they immediately become cached in your application.
When it’s time to trigger an experiment, those same rules are evaluated with zero latency thanks to local execution. The inputs to that assignment decision are never sent out of your app. This is why the privacy of personally identifiable information (PII) is assured.
Other feature flag platforms keep your rules in the cloud, requiring a network call to perform an assignment. Accomplishing trigger testing in this scenario is a little more complicated. It means a developer would be forced to halt execution when the user reaches the triggering point in your app. Then, to put the user on the right side of the experiment, they’d have to make that network call. This process makes trigger testing more work for the developer and a slower experience for the user.
It’s why developers avoid trigger testing in this scenario. As a result, companies miss out on higher quality results in exchange for faster, undisrupted user experiences. A tradeoff like this is not needed with Split. Before subscribing to an A/B testing platform, it’s always a good idea to ask whether client SDKs can make local decisions.
The wrong platform will leave you missing a few important chapters of the whole story. What companies need is carefully contextualized data without muddied results. For the most accurate understanding of the big picture, no metric, number, or impression should be left behind.
Let Your Experiments See the Light of Day
Conclusive data leaves behind little hesitation, but requires embracing a culture of experimentation. Trigger testing is an important tool, but your team is unlikely to embrace it if it requires a performance penalty. Trust a client SDK architecture with an in-app decision engine. So, when the numbers come back, it’s easy to fully comprehend what you’re seeing.
You know the rule: reading in the dark is bad for your vision. Turn the lights on, and let your mission to experiment with crystal clarity rise to the top.