John Arnsdorf

Releasing new features at enterprise scale isn’t just about flipping a switch—it’s about precision, control, and managing complexity at an enormous scale. Imagine trying to roll out a critical update to millions of users, or needing to target a specific subset of customers impacted by a security incident. Most feature flagging tools and homegrown solutions simply can’t provide this level of segmentation.

That’s why Harness Feature Management & Experimentation (FME) introduced Large Segments—unlocking a new level of control for enterprise teams looking to target and release features at scale, without the headaches of managing massive user lists manually.

Why Enterprises Need Feature Management at Scale

According to a recent survey conducted by LeadDev, 42% of enterprise customers are still building and maintaining their own homegrown feature flag tools. While DIY solutions might work for startups or small-scale applications, they fail to meet the demands of enterprise-scale experimentation and rollouts.

Here’s why:

• Security & Performance Risks: Homegrown tools often lack the security, governance, and infrastructure necessary to operate at enterprise scale.
• Experimentation Bottlenecks: Enterprises need to safely test and validate features before full rollout, but DIY solutions often lack robust A/B testing capabilities.
• Phased Rollouts Are a Nightmare: Without an enterprise-grade feature management system, targeting millions of users in waves (e.g., 10% → 25% → 50%) becomes a time-consuming, manual process. 

The further your enterprise grows its digital initiatives, the more managing releases and experiments becomes a logistical nightmare. If you want to experiment, target, and release safely and efficiently, it’s time to embrace a solution built for enterprise-scale feature management with large segmentation capabilities.

Scaling Beyond Traditional Segments

Typically, feature flagging tools allow for small to medium-sized segments, often limited to a few thousand to a few hundred thousand users. But what if your business has 100 million users? How do you efficiently roll out new features or address urgent issues without sinking time into manual targeting?

This is where Large Segments built for enterprise-scale come into play. With Large Segments from Harness FME, you can:

• Target up to 1 million users per segment (expandable to 10 million or more).
• Instantly roll out or roll back features for massive user groups.
• Use pre-built user lists when attribute-based targeting isn’t feasible.

Here are real-world examples:

Imagine a data breach affecting 2 million users of a financial services app. You don’t want to notify unaffected customers—just those impacted. Large segments allow you to create a group of affected users based on imports. Then, you can serve them a targeted notification in-app, offering guidance or security updates. In the end, you’ll ensure a seamless, controlled response, without disrupting the experience for the other 20 million users.

Or, let’s say you’re an eCommerce site launching a new AI-powered recommendation engine. With Large Segments, you can first roll out the feature to 1 million high-value customers, analyze engagement and sales impact, then expand to 10 million casual shoppers, ensuring performance and user experience remain stable before a full release.

This isn’t just adding a little precision to your game; this is huge.

6 Benefits of Large Segments

Large Segments by Harness FME is designed to simplify, speed up, and scale enterprise rollouts and experiments. Here’s how:

1. Faster, Safer Feature Rollouts–In the Millions

With Large Segments, you can enable features for millions of users simultaneously, eliminating the need for slow, incremental updates. This ensures that high-traffic applications maintain stability while rolling out new functionality. It also allows for seamless phased rollouts, such as enabling a feature for 10% of users, then expanding to 50%, and eventually reaching 100%—all while monitoring impact and mitigating risk.

2. Targeting at Large Segments Without Slowing Down Apps

Traditional segmentation methods often rely on database queries that slow down application performance, but Large Segments are optimized for speed. By eliminating these costly lookups, rollouts happen almost instantly, even at an enterprise scale. Updates to segments also occur in real time without requiring redeployment, ensuring teams can adapt quickly without disrupting user experiences.

3. Experimentation on a Massive Scale

Running A/B tests or canary deployments is more effective when you can target large, statistically significant user groups. With Large Segments, enterprises can confidently experiment with millions of users, gathering meaningful insights that lead to data-driven decisions. This ensures that product teams have enough data to measure impact before rolling out features more broadly.

4. Consistent User Experiences

Large Segments ensure that users included in a rollout experience the same feature behavior across all devices and sessions. This prevents issues like “flag flapping,” where a user unpredictably toggles between feature variations due to inconsistent targeting. By maintaining a stable and predictable feature experience, companies can avoid frustrating inconsistencies that impact customer trust.

5. Granular Control Without Complexity

Managing enterprise-scale feature rollouts doesn’t have to involve complex rules or extensive engineering effort. Large Segments allow teams to define user groups based on uploaded lists, making it easy to target specific audiences without writing custom logic. This empowers non-technical teams, such as product managers and marketers, to manage segmentation efficiently without relying on developers.

6. Enterprise-Ready Governance & Security

Enterprises operating in regulated industries require strict governance and compliance controls for feature rollouts. Large Segments help organizations meet requirements like GDPR and CCPA by allowing precise user targeting based on regulatory needs. Additionally, with built-in approval workflows, audit logs, and role-based access controls (RBAC), teams can maintain security while ensuring that only authorized personnel can modify or deploy critical updates.

Large Segments With Harness FME

Large Segments are available to enterprise-tier Feature Management & Experimentation customers.

• Supports up to 1 million keys per segment by default (expandable to 10M+).
• All segment types are now in one place, with a visual indicator of segment type.
• Works client-side only for now (server-side support coming soon).
• Upload entire data files in one go, rather than incrementally.
• Immutable by design, meaning segments cannot be changed once created.

For enterprises, this means greater control, faster experimentation, and more powerful rollouts—all at an unprecedented scale.

Want to learn more? Talk to our team at Harness and see how Large Segments can revolutionize how you release features at scale.

We know that great developer tools should fit seamlessly into the existing workflows and tech stacks that teams rely on. That’s why Harness Feature Management & Experimentation (FME) continues to expand its compatibility across the languages and frameworks developers use most. Today, we’re adding another to the list: the Elixir SDK thin client—now available for general use!

Elixir Developers Can Feature Flag Without Modifying Their Tech Stack

The new Elixir SDK thin client enables teams to integrate Harness feature flagging and event tracking directly into their Elixir applications. Built to be lightweight and efficient, this SDK leverages Split Daemon (splitd) to connect to Harness FME without requiring complex workarounds.

Now, Elixir developers can natively manage feature flags and run experiments—without modifying their existing tech stack or implementing custom solutions.

This feature was initially developed in collaboration with our customer Cars.com, which implemented a minimum viable version of the Elixir SDK to fit their needs. Seeing the broader potential, our engineering team enhanced it for full Harness compliance, and now we’re rolling it out to all customers!

Why a Thin SDK Matters

Elixir is widely used for building scalable, fault-tolerant applications, making it a natural fit for industries handling high traffic and real-time data. By introducing an Elixir thin client SDK, we’re ensuring that teams can:

• Improve Performance: Thin clients have a small footprint and low latency, ensuring real-time flag evaluations at scale.
• Enhance Security & Compliance: No sensitive data needs to be passed outside the local network.
• Simplify Maintenance: Feature flag implementation remains consistent and standardized with other FME SDKs in your organization, reducing the need for custom code or workarounds.

Key Use Cases for the Elixir SDK

With this release, Elixir teams can now:

• Enable Native Feature Flagging – Seamlessly integrate feature management into their applications without external dependencies.
• Simplify Multi-Language Support – Organizations running Elixir alongside other languages (like Python, Ruby, or JavaScript) can ensure consistent feature flag management across their stack.
• Scale with Confidence – The SDK is optimized for high-traffic applications, allowing companies to safely deploy and experiment at scale.

How to Get Started

Ready to start using the Elixir thin client SDK? Here’s how:

1. Install the SDK with splitd – This SDK works in combination with splitd, a lightweight process designed for thin clients. Check out our guide here to get up and running.
2. Implement Feature Flags in Your Elixir App – Use the SDK to evaluate feature flags, track events, and manage rollouts directly within Elixir.
3. Experiment with Confidence – Take full advantage of Harness FME to optimize and fine-tune your releases with data-driven decisions.

The addition of the Elixir SDK underscores our commitment to making feature management accessible, scalable, and secure for every development team—no matter their tech stack.

Check out the documentation to learn more, and let us know how your team is using it!

Experimentation isn’t as risky as it sounds. It’s not like the “experimentation” you did in college. Nor does it have to turn your customers into lab rats—potentially blowing up their online banking experience in the process.

In fact, it’s the opposite! Feature experimentation is about smarter, safer, and faster rollouts—allowing you to test, iterate, and innovate without fear.

And here’s the best part: contrary to popular belief, it’s not just for product teams or marketers; it’s a tool that empowers everyone involved in the development process. 

So, let’s roll back myths as seamlessly as toggling off problem-causing feature flags…

Myth 1: Feature Experimentation Is Only About A/B Testing

The Reality:

‍A/B testing is just one color in the full spectrum of experimentation techniques. Sure, it’s a reliable strategy, but feature experimentation also includes things like multi-variant testing, canary releases, phased rollouts, and feature flags in production.

Multi-variant testing takes A/B testing a step further, letting you test multiple variations of a feature at once. It’s great when you want to compare more than just two versions—think testing several headline styles, button designs, and colors in one go to see what sticks.

Canary releases let you roll out a new feature to a small, controlled group first, testing the waters before going in too deep. If a feature release creates an issue, you can quickly roll it back without making a splash. Similarly, phased rollouts gradually release features, starting small and scaling up to catch issues early on. Experimentation techniques like these are less about discovering your customer’s preferences and more about catching bugs before they bite. 

And, at the core of proper experimentation practices lies feature flags. These integral developer tools are the secret sauce, allowing teams to deploy code without releasing your iterations right away. It's like flipping a switch to test your experiments without disrupting the entirety of your application system. 

A/B testing? More like from A to Z testing. From testing to tweaking, from optimizing and catching issues before they escalate–experimentation is a large collection of strategies to get your software features ready for prime time. 

Myth 2: Experimentation is for Marketers and Product Management Teams

The Reality:

‍Experimentation is no longer just the domain of marketers or product managers. Today, it’s becoming a central focus for engineering teams too. According to a study of 500 engineering leaders at LeadDev, engineering teams are leading the charge in feature experimentation, reaping the benefits of direct feature-level impact measurement. In fact, 42% of them say that experimentation is becoming a central responsibility of their engineering team. And, the teams who excel in this area have one thing in common: the ability to measure impact at the feature level.

So why is engineering stepping up? Feature flags with built-in measurement have made things much more efficient. It started with smarter release monitoring—alerts that show you exactly which flag is causing issues. From there, the leap to experimentation was natural. Now, you can test and gather feedback using the same infrastructure, speeding up your iteration and reducing risk.

Myth 3: Experimentation Slows You Down

The Reality:

‍You might think that experimentation introduces unnecessary complexity and delays. But the truth is, when done right, it speeds things up! With the right tools in place, you can monitor gradual rollouts in real-time, knowing exactly when to ramp up or roll back. If things are going well, you can increase exposure faster. If things aren’t, you’ll spot issues immediately and can pivot before they become larger problems.

Key takeaway: Insight early on is your friend. Using progressive delivery techniques lets you see results even when the experiment is only rolled out to a small percentage of users—say, 10%. You get fast feedback without waiting for full-scale deployment. This means going beyond a faster time to deployment, but a faster time to achieving the customer value teams desire.

The right experimentation platform makes all this possible. They tie feature flags to performance and behavioral data, enabling teams to understand the impact of every iteration—even when rolled out to just a small percentage of users. And with centralized data on a single source of truth, everyone involved in the lifecycle of a feature can be on the same page throughout the entire process.

‍Myth 4: More Experiments = More Risk

The Reality:

‍The idea that experimentation increases risk is actually a misconception. In fact, it reduces risk. With methods like canary releases and production tests, you can monitor real-time performance in a live environment without exposing your entire user base to potential issues. If something’s going wrong, you can catch it early—and make corrections fast.

Look at the case of Sonos, where a major launch without experimentation led to a massive loss of customers, revenue, and a company-wide fear of innovation. A fear that experimentation actually helps solve! When you experiment, you get psychological safety. Teams know they can innovate without the weight of a major release crashing down on them.

In fact, experimentation fosters a culture of fearless innovation—where failure is just another opportunity to learn and improve. By measuring features individually and using real-time data, you can move forward with confidence, knowing you’re making the right decisions.

Experimentation Isn’t a Trend; It’s a Necessary Part of Software Delivery 

Feature experimentation isn’t just a trend—it’s becoming the backbone of modern software development. Whether you’re rolling out a new feature, testing your latest design, or just trying to figure out how to get your product to perform better, experimentation gives you the tools to do it safely, efficiently, and with a lot less risk.

By debunking these myths and embracing the realities, you’ll find that experimentation not only helps you move faster—it empowers your team to innovate boldly. And with the right tools, you can test, learn, and iterate without the fear of failure.

To learn more about how experimentation tools can help, be sure to check out Flagship 2025. There’s an on-demand thought leadership session dedicated to moving past guesswork toward a more insight-based approach. Watch it here.

So, you’ve opted to build your own feature flagging system? Congratulations! You’re about to embark on a journey filled with unexpected complexity, hidden costs, and the distinct pleasure of reinventing the wheel—square-shaped of course (to make it harder for your vision of DevOps modernization to gain traction).

Yes, while a homegrown feature flag solution may seem like an attractive choice at first, the reality is that it often leads to more headaches than it’s worth. But hey, that’s what Ibuprofen’s for, right?

To help you navigate this noble endeavor, we’ve prepared a handy step-by-step guide that outlines everything you’ll need to maintain a truly suboptimal in-house feature flagging system. Follow these steps, and before long, you’ll find yourself wondering why you ever thought this was a good idea.

Step 1: Strongly Secure Your Resources (Vice Grips Not Recommended) 

Building your own feature flag system starts out simple—just a couple of toggles, a few if-statements, and boom! You’re toggling on features with ease. But before you know it, your system needs targeting rules, gradual rollout capabilities, multi-variant testing, and the right mix of real-time analytics to know how your features are impacting customers (whether good or bad).

Now, instead of innovating on your core product, your engineers are moonlighting as full-time feature flag maintenance workers. When they’re not updating your homegrown feature flag tool, they’re likely manually triaging buggy features they deployed because they don’t have a way to automate release monitoring. Expect your engineers spending up to 30 percent of their time maintaining the homegrown tool, and it won’t save you money in the end. The average cost of maintenance is 25% of the initial build year-over-year.

Pro Tip: Every hour your team spends maintaining your homegrown solution is an hour not spent building new product features. Without proper feature management, you can plan to grow your backlog of feature releases. 

Step 2: Grab a Calculator, Start Subtracting From Your Bottom Line

Outages? Never heard of them—until your DIY feature flag system causes one. These become more and more likely as you scale up your efforts and the number of poorly-managed, stale, or unused feature flags slowly clutter your codebase.

All it takes is a single misconfigured flag to take down an entire production environment, and guess what? Enterprise downtime costs an average of $12,000 per minute. While your engineers scramble to debug an obscure flag evaluation issue, your company is hemorrhaging cash. Have a powerful calculator that can keep up with all the subtraction––in your back pocket next to that fat Costanza wallet you’ll need. Poor lower back.

Pro Tip: If your internal system doesn’t have built-in safeguards, rollback mechanisms, or real-time monitoring, you might as well start budgeting for your next major outage now.

Step 3: Try Ibuprofen for all Those Security Headaches

Homegrown tools tend to expose customers to security vulnerabilities. Unlike professional platforms, these tools often lack in-app decision engine SDKs, which are crucial for ensuring that no Personally Identifiable Information (PII) is shared with the cloud. This lack of robust security features can lead to breaches, compromising customer trust and incurring significant remediation costs.

The last thing you want is a data leak on your watch. There is no wrench that can tighten up that problem. Ibuprofen might help soothe a minor headache, but not the fallout from customer PII winding up in the wrong hands.

Pro Tip: If your in-house system isn't built with security-first principles, be prepared for the fallout from potential data leaks. 

Step 4: Embrace the Joy of Manual Configuration and Compilation (If That’s Even Possible)

Ah, the joys of manually configuring feature flags! Every new release means hand-editing config files, manually compiling customer lists, and praying no one makes a copy-paste error. Rolling out a feature to a test group? Time to fire up a spreadsheet and manually track who gets what—what could possibly go wrong?

Support tickets? Good luck. Without centralized data, your support team will spend their days asking, "Uh, which version of the app is this customer even seeing?" Meanwhile, engineers wrestle with bloated config files, stale flags, and the creeping sense that their lives have taken a very wrong turn.

Pro Tip: If your release process requires a Google Sheet, a Slack thread, and a sacrificial offering to the deployment gods, it might be time to rethink things.

Step 5: Scale Up for the Enterprise and Say Hello to Your Breaking Point

Homegrown feature flags may kind of work for a small team, but the moment you scale, things go sideways fast. Need role-based access control? Custom dashboards? Compliance tracking? Congratulations—you’re now in the business of building an enterprise-grade permissions system from scratch.

Cross-team coordination gets messy. Feature ownership becomes a mystery. Soon, your "simple" internal tool has spiraled into a Frankenstein system held together by duct tape and regret. Auditors want an audit trail? Good luck scraping logs. Leadership wants feature visibility? Time to build another tool.

Pro Tip: If your DIY solution requires a full-time team just to keep it from collapsing under its own weight, it’s no longer a solution—it’s a problem.

Step 6: Finally Come to the Realization, It’s Better to Sign Up for a Feature Management Platform Instead

Congratulations! After enduring all of the above, you’ve finally reached the logical conclusion: Building and maintaining your own feature flagging system isn’t the best solution long-term.

Instead of throwing more engineering hours into a system that will only grow more complex (and fragile) over time, it’s time to explore purpose-built feature management solutions. These platforms come with:

✅ Advanced targeting and segmentation

✅ Reliable rollback mechanisms

✅ Built-in experimentation frameworks

✅ Robust analytics and logging

✅ Enterprise-grade security and compliance. The list keeps on going.

Final Pro Tip: Skip the pain and start with a solution designed for the job. Your engineers—and your CFO—will thank you.

Conclusion

DIY feature flag solutions may seem like a smart move at first, but as they scale, they introduce more problems than they solve. Hidden costs, resource drain, technical debt, and security risks turn what seemed like a simple project into a never-ending nightmare.

Enterprise-ready feature management platforms eliminate these headaches by providing robust security, scalable infrastructure, and sophisticated experimentation frameworks. They offer automation, governance, and cross-team collaboration features that organizations would struggle to build in-house. Investing in a purpose-built solution ensures efficiency, security, and reliable feature management—so your teams can focus on innovation instead of maintenance.

It makes sense. DIY projects can be rewarding. However, it’s probably time to leave the DIY experiments for home improvement projects. You could expend that energy building a birdhouse, repainting shed, or even assembling Ikea furniture. 

To get the full story on DIY Feature Flag Solutions, be sure to download “The Ugly Truth About DIY Feature Flag Tools”.

This year, Harness brought together innovation leaders from top enterprises like McDonald’s, ADP, and Chase to share how they’ve revolutionized their software delivery using safer, smarter release processes and experimentation-led cultures.

It wasn’t just another tech event—it was a moment for product, engineering, and leadership teams to come together to challenge the software development status quo. Watch the event on your own terms and learn from the best in the industry.

On Demand Thought Leadership Panels

Releasing software shouldn’t feel like a high-stakes gamble. The most successful teams are moving away from risky, big-bang releases and are instead experimenting, measuring, and iterating their way to success.

Flagship 2025 made feature measurement and learning a central topic of discussion. With measurement at the core, featured sessions touched upon topics such as building cultures of experimentation, accelerating innovation at scale, and making data-driven product decisions. Whether you’re looking to refine your A/B testing strategies or elevate your engineering department into a hub of excellence, Flagship recordings offer real, actionable insights to help you apply data-informed product innovation today.

Watch every session here.

7 Months Post Acquisition: Split Is Now Integrating Into Harness

Flagship 2025 was a milestone moment for us. Seven months ago, Harness acquired Split with the vision to bring both platforms together to create a unified, end-to-end solution for managing the entire software development lifecycle.

The migration of Split customers onto the Harness platform is fully in motion, paving the way for a more streamlined software delivery experience. This means Harness users can leverage advanced feature management and experimentation, while existing Split users gain seamless access to the full array of Harness offerings—all under one secure, convenient platform.

Missed the details of this game-changing shift? Don’t worry—watch the opening session to understand how this integration is shaping the future of software delivery and DevOps modernization.

New Experimentation Capabilities to Keep You Measured

Since Split joined Harness, we’ve accelerated innovation at an unprecedented pace, boosting velocity by 70% and announcing new Experiment Workflows. 

At Flagship 2025, we gave a first look at these new capabilities, including enhanced customization for designing experiments and a comprehensive dashboard that gives teams real-time visibility into experiment performance. With these tools, you can measure every iteration without slowing down your teams. Because when you can measure everything, you can improve everything.

Hear Real-World Success Stories From Enterprises Like ADP

Flagship 2025 wasn’t just about product updates—it was about hearing from real companies who’ve successfully transformed their software delivery practices.

One standout story came from ADP, the world’s largest provider of human resources, payroll, and benefits outsourcing. Chris Davis, VP of Product Development, shared how ADP migrated from a DIY solution to a robust feature management and experimentation platform. 

Catch Chris’s session, “Beyond Lines of Code,” to hear how ADP made this leap while serving over 15 million users, and be sure to check out the newly released case study. 

Grab the Bull By the Toggle at Flagship 2025

If you’re ready to put your flag in the ground and take experimentation and release practices to the next level, watch Flagship 2025 on demand. The future of software delivery belongs to those who innovate boldly—don’t miss your chance to be part of the conversation.

Watch now and stake your claim on the future of feature management and experimentation.

Request a demo

Checkout Harness Feature Management & Experimentation