Too many companies skip the needed alpha beta program
If I staked out an empty spot in Dolores Park and set up a table with a sign that read “Are too many products in beta”? I’d get a pretty polarized result. Some, likely engineers, would claim that alpha and beta are commonplace buzzwords that make for snazzy product launches. Others, especially those in administrative roles, would claim that not enough products label themselves as beta when they are clearly unpolished.
In short, alpha and beta labels are invited by some, but scorned by others. There’s some logic to this partition. Alpha and beta labels are often misused; at the same time, they are seriously underused by companies attempting to build successful, robust products.
To clear the smoke, I am going to make a case for when—and more importantly, why—companies should consider alpha and beta programs.
Alpha and beta have become buzzword-y over time, so let’s establish the core differences between alpha, beta, and released products. Granted, there is little consensus over the exact definitions of each. There isn’t even agreement about where the terms originated; Wikipedia credits IBM (specifically IBM engineer Martin Belsky), but there’s no cited credible source.
Even with blurred lines, the median alpha, beta, and released product could be set apart by some core differences.
An alpha product is a perceptibly unfinished product. While products are always growing and improving, an alpha product is missing a core feature (or features) that could be essential to its success. For instance, a financial tool may be considered alpha if an exporting transactions feature isn’t built yet.
Alpha products might lose data, render incorrect results, or be painstakingly slow. Because alpha products are likely to break, adopters tend to be risk-forgiving. These adopters aren’t expecting a seamless experience; they are merely testing (and supporting) an early product that may be useful upon its maturity. I wouldn’t go as far to claim that alpha adopters are doing charity work, but they’re helping the product’s developers as much as they’re being helped themselves.
Speaking from experience, our alpha users helped signal to us what was important, what was broken, and what caused outages. Mainly, they pointed out the “unhappy paths” we should have designed for as well, and gave their inputs for the next development cycles: integrations, analytics features.
By design, alpha programs tend to be short. Often, the goal of an alpha program is to measure early user impressions while the team finishes up core features that are key to the beta.
Beta products are functioning but unpolished. Beta products may have poorly or partially designed views and very rudimentary secondary features, and they may be littered with bugs. A beta adopter can typically expect to hit a hiccup if they choose to use the early product routinely.
Beta programs can last a very long time. There’s a bit of amusement in Silicon Valley over companies with endless beta programs. Some companies have extremely rough rubrik before qualifying a release as a polished product. Others may do the opposite, exiting beta as soon as a majority—but not necessarily the entirety—of the kinks are worked out.
A common misconception is that beta products are invite only. While alpha programs often are selective, both alpha and beta programs can be open access; the alpha and beta flags are just disclosures of a product’s stage, not its availability.
A released product is a product that is considered complete by the developer, with no major issues remaining. Of course, products will continue to grow—released candidates are just advertised as competitive offerings that are punching their weight.
While this article is mostly a case for using the alpha and beta labels, I’ll take a moment to acknowledge the detractors.
The public distrust of the Greek-lettered release stages—especially beta*—*has existed for a long while. In 1996, [TidBITS](https://tidbits.com), a popular Apple-focused newsletter, [released an edition](https://web.archive.org/web/20060515093203/http://www.tidbits.com/tb-issues/TidBITS-328.html#lnk5) lamenting the broad dependence on the beta label. The general sentiment was that too many “in-beta” products were flooding the market. This decade-old [Tom Fishburne](https://marketoonist.com/2010/08/always-in-beta.html) comic captures the frustration well.
Granted, this distrust is nuanced. If a just-founded startup launches its product in beta, there’s nothing wrong with that and nobody will cry foul. Rather, some buyers—especially enterprise buyers—are disappointed when well-funded juggernauts release half-finished products. Google [is pretty notorious](https://techcrunch.com/2009/05/20/googles-beta-love-may-die-in-fight-for-enterprise-customers/) for this, keeping products in beta for years, including Gmail for half a decade after its launch.
However, while some users might consider beta an overused term, what matters is a company’s internal attitude toward beta programs. A few eye rolls from consumers won’t break a launch, but a poor culture around a beta program can. This is a perfect segue into the next topic: What is a beta program’s true purpose?
Without naming names, the actual problem with some beta programs is that the label becomes an excuse for sloppiness over anything else.
An alpha or beta label is a disclosure. It’s telling your customer,” Hey, this may underperform expectations of a finished product”. It helps customers make a better decision about whether they should adopt your product now (while it’s being ironed out) or later (when it’s formally released).
A good way to demonstrate this difference is by posing a hypothetical. Imagine an irate customer emails support citing a critical issue with a data export feature. If your team reacts with “We’re in beta; why are they so mad?”, then you’re using your beta status as an excuse.
Instead, the reaction and response should be to the tune of:
“Thank you for flagging this. Reports like this help us get closer to a polished product.”
More succinctly, an alpha or beta program should act as an accelerant. It should help teams reach a stable build faster by leveraging feedback dispatched by customers. The last thing it should do is slow development by serving as a crutch to save face whenever bad things happen. A team developing an alpha product should prioritize getting to beta as soon as possible (without compromising the product’s integrity). And a team developing a beta product should do the same toward a v1 release. The labels are training wheels, not liability insurance.
Another way of thinking about this is that reported bugs should be treated the same no matter if a product is an alpha, beta, or polished release. At all stages, bugs are simply prioritized in relation to their urgency. Alpha and beta stages are actually excellent periods for engineering teams to establish great practices that’ll last and position them for long-term success.
If we were to think in the context of the behemoths, this might seem like a diatribe against Facebook’s infamous “move fast and break things” philosophy. Honestly, it is. Facebook [is still riddled with](https://darkcoding.net/software/facebooks-code-quality-problem/) poor engineering practices that resulted from its “we’re an early-stage company, we can make mistakes” culture.
On the flip side, too many companies underutilize the alpha and beta labels. In fact, most companies don’t use either, instead optimizing for immediate user acquisition.
The labels aren’t too pertinent if a product is closed access, where onboarded users are chosen based on their compatibility with the minimal features available. However, if a company is releasing a generally available but incomplete product, using a beta label is probably a good idea.
Remember, while beta is signaling that a product won’t be a perfect experience, it’s not signaling that it’s going to be a bad experience. Companies can still build strong user bases on beta-flagged products. As a bonus, this filters for avid users who will be extra forgiving of early bugs. This, frankly, is much better than an unsuspecting user signing up for a practically beta product, having a bad experience, and then forever assuming that it’s poorly engineered.
Being an open-source company, we are big on transparency. By flagging the early releases of Lago as alpha builds, we built trust with our users that our product might break and is lacking some core features (like credit notes).
We still got great adoption.
Here, our biggest takeaway was validation. We actually didn’t expect respectable companies to craft a billing system on an alpha product. It’s such a mission-critical feature. But even with our early releases flagged as alpha—something that indicated that a Lago-built billing system ***********might break—***********we still got adoption. Which felt pretty good. It was validation that we hit a real problem.
For founders, this is another good reason to consider leveraging alpha and beta programs. It’s a great way to suss out whether your product will succeed. The earlier you figure that out, the better. And if you can get real adoption on your alpha or beta program, you are likely doing something right.
Don’t get it twisted, alpha and beta programs are good tools. Companies just shouldn’t rely on them as a crutch to excuse bugs. They are simply something to communicate, “Hey, this shiny new thing is early!” It’s no different from using a status page to communicate availability or a release log to showcase changes and reported security issues.