As DevOps teams shift to agile methodologies for continuous delivery of features, developers increasingly require more granular control over deployments and feature exposure. Given accelerated deployment, testing, and iteration of software changes, teams need to leverage nuanced risk management mechanisms to preemptively address issues before they impact customer experiences. In the event of issues arising post-launch, developers require the flexibility to toggle features on and off, ensuring uninterrupted service by deactivating features responsible for errors. In addition, developers want to tailor features to specific end users without needing to write additional code or even rewrite source code.

Increasing demand for visibility into the development processes has driven the growth of feature flag adoption. Teams employ feature flags as a mechanism to continuously ship and release code, streamlining experimentation, canary releases, and code rollbacks if bugs arise. With feature flags, developers gain greater control over test environments and relevant analytics, facilitating the restoration of original environments with limited downtime. Feature flags provide the flexibility to control user experiences, release features when intended, and solicit relevant user feedback. Engineering teams employ feature flagging tools as a mechanism to deploy faster, control releases, and modernize applications, leveraging flags for aspects of the development process ranging from releases to experimentation.

LaunchDarkly provides a feature management platform designed to de-risk software releases, ensure targeted experiences, facilitate product experimentation, and optimize mobile releases. For developers looking to improve the velocity and stability of their software releases, LaunchDarkly generates analytics around release quality, velocity, and risk along with more granular information around flag health and specific experimentation impact. LaunchDarkly’s mission is to create a world in which every software release is safe and unceremonious via a developer-first solution, helping teams launch, control, and measure their digital products.

Founded in 2014 by Edith Harbaugh (CEO) and John Kodumal (CTO), LaunchDarkly provides an end-to-end feature flagging platform to improve the stability of software releases. Harbaugh, who previously served as product director of trip planning platform TripIt, realized that the company’s homegrown workflows for feature development required continuous rebuilding of identical processes from scratch. While launching product lines for TripIt’s small business devision, Harbaugh realized that the broader shift to the cloud facilitated higher velocity releases and provided more agility for developers seeking visibility into application performance.

Kodumal, who previously headed Atlassian’s marketplace segment as an engineering manager, had previously built an internal flagging tool for engineers within the company. In an instance where Confluence was listed as free of charge, Kodumal realized that the original listing should’ve been feature flagged, and any further changes should have been rolled back without the need for redeployment. Instead, the team was forced to remove Confluence from the carts of users who had begun to purchase inaccurately priced licenses.

Harbaugh similarly had encountered homegrown tooling at other companies but realized that widespread adoption of feature flagging had yet to gain traction. While larger firms such as Amazon or Facebook had the capability to develop infrastructure for deployment management, smaller and even medium-sized companies often lacked the resources to develop similar frameworks.

While Harbaugh and Kodumal had known each other since college, it was only in 2014 when both were searching for different career paths that they resolved to tackle the issues of feature flagging at scale. Although engineering blogs of larger organizations seemed to indicate existing rich toolkits designed for feature release testing, such tools weren’t widely available for other organizations. Adoption of such an internal feature flagging solution also entailed organization-wide usage, contributing to friction within the development process.

The duo started LaunchDarkly with the intention of streamlining feature management, enabling developers to deploy features to production in a more scalable, resilient manner. Despite facing rejections from Y Combinator and numerous investors when fundraising, Harbaugh and Kodumal maintained that feature management would become the backbone of modern, cloud-based software development.

Although LaunchDarkly’s Product Hunt launch fell short of expectations (with only one qualified lead originating from the launch), the founders continued in their approach to brute-force marketing by blogging about the benefits of feature flagging, speaking at developer-centric conferences, and even experimenting with AdWords.

LaunchDarkly’s early customers, notably the product design platform InVision, helped drive early adoption of the product, but Harbaugh realized that selling to internal organizations still proved difficult given broader reluctance around purchasing external tools versus building the same solutions in-house. With InVision as a marquee customer, the team continued selling to other teams, developing the company’s go-to-market motion with the backing of a few early adopters and developer friends, including some of Harbaugh’s former colleagues. Although LaunchDarkly initially honed its focus around soft-launching features and code for smaller subsets of users, the company broadened its reach to include marketing and business operations teams, aiding them in activating features for intended users.

Feature flagging involves wrapping newly written or potentially risky portions of infrastructure changes with a flag, which can then be turned either on or off at the developers’ discretion. Feature flags enable the development team to assess features in production while mitigating potential fallout from less robust releases, ensuring reliability and consistency while facilitating experimentation. By validating the functionality of potential releases within simulated production environments, feature flags help teams modify code without causing changes in live code environments.

Feature flags can be employed across a number of use cases ranging from de-risking software releases to bolstering reliability, creating targeted software experiences, and streamlining product experimentation or A/B testing. Release management encompasses early access programs (wherein specific subsets of users are provided early access), canary releases, and beta programs where developers can observe the behavior of systems under varying loads while aggregating useful feedback.

Feature flags can also ensure operational health, specifically in terms of toggling specific features either on or off to minimize incident impacts. Circuit breakers or kill switches can be deployed to mitigate detrimental impacts on user experience, and developers can opt to switch over to a less feature-rich version when mounting heavy loads. Within the feature flags, developers can also assess the viability of migrations to disparate microservices or other third-party dependencies active in production.

Feature Flags

Source: LaunchDarkly

LaunchDarkly’s feature flags provide granular, real-time visibility, context-aware targeting, and product experimentation capabilities. With coverage for software development kits (SDKs) across all major platforms, LaunchDarkly’s SDKs cache all relevant information for flag processing once initialized, enabling the platform to process flag changes without reducing client-side application latency. The platform’s SDKs streamline feature flags integration while providing caching and streaming for every major programming language across server, client, and mobile applications.

With LaunchDarkly’s streaming architecture, users can deliver feature flag updates to all servers and clients within 200 milliseconds. The company’s flag delivery network employs a third-party content delivery network (CDN) with distributed core architecture components to facilitate accelerated experiences, ensuring that applications can be initialized within 25 milliseconds.

LaunchDarkly claims its core architecture is secure, highly available, and spans multiple availability zones, facilitating consistent experiences regardless of geography. Once an application has been integrated with a LaunchDarkly SDK, the SDK initializes within application code, storing the feature flag payload and evaluating the flag within application memory. Applications reportedly serve feature flag variations near-instantly, with the SDK sending information about flag evaluation back to LaunchDarkly.

LaunchDarkly supports both boolean and multivariate flags, enabling users to add variations for complex use cases or multiple variations of the same feature. For instance, developers can opt to use a boolean flag when comparing two color options, or alternatively use multivariate flags in trialing several different colors for the same button.

Multivariate flags facilitate customization, with number, string, and JSON flag types, particularly for nuanced workflows. Custom rules enable users to target disparate contexts in refining rollouts. As one example, the first rule may serve two-click checkout for all customers within the US while the second rule targets customers whose email ends with .edu, serving one-click checkout to a select 10% of the user base.

Source: LaunchDarkly

From the targeting tab, users can opt to release specific features to select segments, individuals, and even mobile applications and devices. Each targeting rule includes a description, along with one or more conditions, and rollout details. Each condition contains context kind or attribute, which helps define the scope of the condition’s impact, along with an operator, which sets differentiating characteristics of the attribute, and a value, which helps identify the attribute by a specified value. The rollout describes what sort of flag to serve when the targeting rule is met, and the rollout itself can be set to any variation of the flag, or even a percentage rollout.

Release Management

Common deployment models include ring and percentage deployments, where ring deployments entail different groups gradually receiving the feature (e.g. releasing features to internal users before rolling out the release to beta and then all users). Percentage deployments operate by randomly rolling out feature releases to a subset of the total user base, which can prove particularly useful when there’s no large variation in users or when running a beta program.

To achieve frictionless releases, teams may also opt to undergo canary deployments (also known as phased or increment rollouts) wherein new deployment of applications are rolled out to a specific group or percentage of users prior to being released to everyone.

Blue-green deployments include two identical production environments wherein one environment remains active while the other stays idle. New releases are deployed to the idle environment, and blue-green deployments minimize the risk associated with deploys by maintaining the most recent working configurations to roll back to if any issues occur.

Targeted release management can enable developers to roll out features to specific subscription tiers, facilitating user personalization and compliance with regulatory requirements. If a retailer wants to target their customers based on subscription tier, they can opt to target users in a specific segment to ensure that only that subset of the user base is presented with the new feature. Once the retailer has determined a list of metrics for tracking the efficacy of a new module, developers are able to connect those metrics to LaunchDarkly’s experimentation before launching targeted releases.

Cloud Migrations

Source: LaunchDarkly

Feature flags can also mitigate risks affiliated with software migrations, specifically in terms of avoiding downtime in cloud migrations. By observing infrastructure migrations using feature flags, developers can ensure that any changes made will avoid performance degradation. While some kinds of migration may only necessitate two stages (where developers switch directly from older systems or data sources to newer ones), they may perform incremental migrations by following a percentage rollout to the newer variation.

Four-stage migrations may entail using two systems simultaneously (with one system solidified as the authoritative system, with results from other implementations not explicitly returned). In a four-stage migration, developers are able to compare the performance of services (e.g. different versions of the same API endpoint) or monitor the decomposition of a monolith into separate microservices.

Feature flags can also be used to streamline six-stage migrations in which data migrates from one system of record to another, but specifically in the context of replicating data between implementations. Old implementations can be automatically applied to new implementations as in-band writes are applied to both implementations, thereby ensuring data consistency.

Outage Prevention

Developers today grapple with balancing the velocity and stability of software releases, fearing the risk of potential outages or negative customer experiences. LaunchDarkly extricates software deployments from releases, facilitating the progressive rollout of features by validating features in production before exposure to customers.

If any issues materialize, developers can simply roll back problematic releases, disabling erroneous code via a single toggle. Beyond streamlining feature delivery, LaunchDarkly ensures that developers are able to limit the potential blast radius of new releases by releasing such features to a smaller group of internal testers before incrementally rolling out the release to larger customer segments.

Load Shedding

When sites experience unexpected spikes in traffic, load shedding helps mitigate pressure by ensuring that essential tasks can be performed under heavier workloads. Disabling features in such scenarios can be instrumental in increasing database latency and mitigating system stress; teams can opt to turn off features that are more resource-intensive or any features that may perform sub-optimally under load.

Feature Experimentation

Source: LaunchDarkly

In addition to using LaunchDarkly to orient feature launches to specific users to ensure performance, customers can also use the platform for experimentation or A/B testing, which can prove crucial to honing in on user insights like the frequency of usage or whether certain features are performing as expected. LaunchDarkly’s Experimentation functions can be used to assess the functional value of shipped features, including specific variations of UI / UX components. In the Results tab, LaunchDarkly provides insights into which variation should be the best choice out of variations being tested. Once a developer has chosen a specific flag variation, they can initiate the gradual rollout of a selected variation to their core customer base via the percentage rollout feature.

Product experimentation extends across the stack, enabling developers to run back-end or infrastructure optimization experiments, whether that be measuring the impact of new APIs on page load times or the impact of database implementation on system performance. Insights generated from experimentation can be exported to external data warehouses and subsequently pushed to business intelligence tools (e.g. Tableau, Looker, PowerBI). Developers can utilize their preferred data warehouses or tools to analyze event data in Google Cloud, Amazon Kinesis, Segment, mParticle, Azure Event Hubs, or Snowflake.

Integrations

LaunchDarkly offers feature management as a service via over 25 software development kits (SDKs) for front-end, back-end, and mobile development. The feature flag platform includes support for a number of integrations with companies like Datadog, Honeycomb, New Relic One, Slack, Jira Cloud, ServiceNow, Cloudflare, and more.

LaunchDarkly’s Slack integration enables developers to view and filter flags, subscribe to flag notifications, and toggle flag targeting. The platform’s Jira integration allows developers to directly link feature flags to Jira issues, with associated Jira issues displaying the flag’s current status based on whether the flag has either been turned on or off. Integrations with APM tools (e.g. Datadog, AppDynamics, Honeycomb) enable developers to assess whether performance changes or issues in the application can be attributed to feature flag changes.

Engineering Insights Hub

Source: LaunchDarkly

LaunchDarkly’s engineering insights enables developers to track key engineering metrics to bolster efficiency, helping measure collective outcomes from deployments and releases. By coupling metrics with data from code, build tools, incident reports, and other relevant telemetry data, LaunchDarkly helps teams to identify bottlenecks and assess long-term development trends.

Project metrics within LaunchDarkly’s engineering insights hub span velocity, risk, and efficiency, with insights around deployment frequency, lead time, deployment failure rates, large-impact flag changes, stale flags, and overall experimentation rates. The broader summary section provides an eagle-eye view into release maturity calculated from assessments of the project’s velocity, risk, and efficiency scores.

Customer

Source: LaunchDarkly

LaunchDarkly’s customers span financial institutions, developer infrastructure startups, enterprise technology companies, airlines, and consumer-facing tools. Notable customers include Square, IBM, Santander, NBC, Vodafone, Atlassian, NCR, SoFi, and Hewlett Packard.

Companies like Intuit notably employ LaunchDarkly’s feature management solution to construct a central source of truth, providing teams full visibility into relevant flags across environments and insight into key dependencies. Prior to using LaunchDarkly, Inuit’s homegrown feature flagging system was often prone to errors because the incumbent system relied on configuration files, forcing developers to make feature changes within the actual codebase.

For Intuit, alterations to feature flags could sometimes take 10 minutes to go live for end users, and any users who had active sessions would see stale versions of the flag unless they had actively refreshed their session. LaunchDarkly provides high-level visibility into flags instantiated across environments and highlights relevant dependencies across teams. Within the first six months, more than 600 feature flags were created across Intuit’s organization, and teams were able to provide features in beta testing groups and perform strategic rollouts. In one instance, Intuit’s data science team was able to experiment with releasing an idea to live users, presenting the test option to 45K users when trialing the feature.

Like Intuit, cloud-native observability platform Chronosphere utilizes LaunchDarkly to manage their release program by using feature flags to enable detailed logging and traces when errors arise in production. In addition, Chronosphere’s engineering team streamlined application debugging to avoid the need to redeploy and potentially lose context around the origination of the issue.

Market Size

The DevOps market was valued at $10.4 billion in 2023 and is projected to reach $25.5 billion by 2028 (19.7% CAGR). Given the proliferation of DevOps tools and vendors, teams have increasingly adopted end-to-end solutions that facilitate the development lifecycle. Emerging focus on assessing and improving developer productivity has led to the adoption of tools like feature flags, with developers looking for tools to increase visibility into codebases during testing and deployment.

While continuous integration and testing tools make up the bulk of the DevOps market, solutions that address migrations remain critical as teams look to active writes into new database columns. By decoupling database changes from code changes, teams can mitigate downtime and risk, and leverage kill switches to discard non-critical data when writing data to intended databases. While the duration of cloud migrations typically depend on the complexity of migrated workloads, along with the deployment model and volume of data to transfer, migration costs can range from $5K to $100K. Feature flags can ensure data integrity via comprehensive testing, ensuring optimal user experiences even during more nuanced database migrations.

Split

Founded in 2015, Split provides a feature delivery platform to streamline feature observability and testing for developers. The platform’s Feature Data Platform provides more nuanced, contextual information around releases while Instant Feature Impact Detection (IFID) hones in on issues during progressive delivery overlooked by traditional monitoring tools.

While Split offers similar coverage across basic feature flag use cases, the platform lacks flag scheduling functionality, along with multi-environment control and flag triggers, forcing developers to manually monitor metrics in identifying which features to turn on or off. While Split offers SDKs across a number of languages and frameworks, Split doesn’t include the same level of granular control when constructing automated workflows. While LaunchDarkly remains compliant with regulations, Split lacks ISO 27701, FedRamp, and HIPAA compliance.

Split raised a $50 million Series D led by Owl Rock in August 2021, bringing the company’s total funding to $109.8 million.

Optimizely

Founded in 2010, Optimizely provides a broad suite of multivariate testing tools for teams seeking visibility into their marketing lifecycles. Optimizely’s platform facilitates feature experimentation, streamlining the delivery of customized commerce experiences, and relevant product recommendations.

While LaunchDarkly continuously streams and provides real-time updates for client and server-side experiences, Optimizely polls at intervals and lacks the scalability for larger enterprise applications where feature flag management must operate across disparate environments.

LaunchDarkly’s custom contexts reflect the data model, business language, and historic release process during product delivery and experimentation processes, but Optimizely lacks the same nuance in delivering personalized user experiences given existing data. With LaunchDarkly’s targeting engine, users can opt to target specific devices, users, or even geographies while integrating experiments directly within the development workflow. Beyond honing in on target segments, LaunchDarkly integrates feature management and experimentation within a unified platform, enabling product managers to ship experiments in tandem with development teams.

Optimizely raised a $50 million Series D in June 2019, bringing the company’s total funding to $105 million before it was acquired by Episerver in October 2020.

Harness

Founded in 2017, Harness provides end-to-end continuous integration and continuous delivery (CI / CD) platform with products spanning feature flags, chaos engineering, service reliability management, security testing orchestration, and cloud cost management. Harness’s CI/CD solution integrates with vendors across the broader DevOps stack to ensure that developers can safely develop, deploy, and monitor microservices.

While Harness offers feature flagging as part of its DevOps platform, the platform’s coverage extends beyond feature flagging and product experimentation, encompassing elements of the broader software development lifecycle. The platform provides a full-service solution that spans the development process, ensuring that developers gain full visibility into their deployments, even enabling teams to synchronously run deployments without any additional oversight.

Harness enables developers to launch incremental feature releases, ensuring smoother transitions to production while minimizing potential issues for end users. The platform’s feature management facilitates nuanced feature A/B testing, integrating directly into existing CI/CD pipelines to streamline the development lifecycle.

Harness raised $230 million in funding at a $3.7 billion valuation in April 2022.

Source: LaunchDarkly

LaunchDarkly offers Starter, Pro, and Enterprise pricing tiers. While the Starter tier is geared primarily towards smaller teams; the Pro and Enterprise tiers provide support for scalable workloads and cross-organization experimentation for distributed teams.

Starter: Geared towards smaller teams looking to reduce time spent on building homegrown feature flags, LaunchDarkly’s Starter is priced at $10 per seat / per month. The Starter tier ensures access to over 25 SDKs and integrates with workplace applications like Microsoft Teams and Slack to ensure consistency across developers and user-facing teams. With support for 1K client-side monthly active users (MAUs), the Starter plan offers support for limited targeting and flag management but lacks scheduling functionality and workflow approval automation.

Pro: For teams seeking a scalable feature management or experimentation solution, LaunchDarkly’s Pro tier is priced at $20 per seat / per month and provides unlimited projects and server-side MAUs, along with 10K client-side MAUs and up to 300K additional client-side MAUs. In addition to the features encompassed in the Starter tier, LaunchDarkly’s Pro tier also provides reusable segments and peer-reviewed flags, along with extended integration access and more granular API controls.

Enterprise: LaunchDarkly’s Enterprise tier operates under a bespoke pricing model, with specific quotes required based on MAU scale and broader feature experimentation and data export functionality. The Enterprise tier also provides workflow automation across flag scheduling, required approvals, and flag triggers.

LaunchDarkly services a range of companies from larger enterprises to earlier startups, with the company announcing a milestone 5K global customers in November 2023, including logos like EasyPark and Verily Life Sciences. The company was named to the 2023 Forbes Cloud 100 given its coverage across the Fortune 500, with 25% of companies using LaunchDarkly to deploy their software. Notable customers include HP, Intuit, IBM, Hawaiian Airlines, CircleCI, Loom, and Atlassian.

With LaunchDarkly, engineering teams have increased release velocity by 9x, reduced service outages by 97%, and ensured that over 99% of users are provided bug-free software experiences. With over 20 trillion feature flags served to users and 3 million servers worldwide, LaunchDarkly ensures a 75% decrease in time from commit to deploy. In January 2024, one unverified source indicated that LaunchDarkly had exceeded $60 million in revenue.

LaunchDarkly raised $200 million in funding in August 2021, tripling the company’s post-money valuation from 2020 to $3 billion. The Series D, led by Lead Edge Capital, included participation from existing investors Bessemer Venture Partners, Redpoint, Threshold, Uncork Capital, and Bloomberg Beta. The Series D brought the company’s total funding to over $330 million. LaunchDarkly’s Series C took place in March 2019, with the company raising $44 million from Bessemer Venture Partners and participation from existing investors Redpoint, Vertex Ventures, DFJ, and Uncork Capital.

AI Application Experimentation

Source: LaunchDarkly

Given the rate of new AI models being released, developers increasingly require flexibility in their model configurations. LaunchDarkly enables developers to iterate on providers, models, and prompts, assessing the efficacy of models in place and experimenting across product features. Through the LaunchDarkly SDK, developers can enable or disable new models, using feature flags as a kill switch to disable any models that yield unexpected results.

Source: LaunchDarkly

Beyond toggling with models, LaunchDarkly can help with optimizing and releasing prompts, enabling further experimentation for specific models or configurations given the context of usage. Developers can instantiate token limits and modify token usage based on user’s account types to further curtail costs and provide more tailored end experiences.

Developers can also leverage LaunchDarkly’s runtime experience to add or edit existing prompts, targeting them to specific cohorts or customer segments within given environments. In a similar vein, developers can define model availability via the LaunchDarkly platform and then opt to toggle between configurations using feature variations. The ability to configure model availability also unlocks broader possibilities such as self-service opt-in for given models, and even team-based targeting for model usage.

Beyond iterating on different model providers and prompts, developers may also use LaunchDarkly in measuring the efficacy of such changes. If new models are conducive to higher product conversion, developers may opt to apply product experiments directly to features while measuring the impact of such changes.

With the features geared towards deploying AI-first applications, LaunchDarkly could become the platform of choice to centrally manage disparate features across workflows, even displacing tools that embed directly within continuous integration/continuous delivery platforms (CI/CD). In the context of model development and deployment, LaunchDarkly enables developers to effectively ship AI applications by providing more granular controls for model usage, adoption, and releases.

Release, Remediation, & Migration Assistance

Source: LaunchDarkly

LaunchDarkly’s Release Assistant provides guardrails around how to ship features across disparate environments, streamlining otherwise complex automations to stitch environments together. The Release Assistant helps pinpoint progression paths, aligning releases with the status of all cross-organization releases. Automated rollbacks mitigate risks associated with bugs entering the live codebase while ensuring more granular control over traffic directed to test environments, consistent performance, and restoration of historical environments with limited downtime.

In tandem with Release Assistant, Release Guardian enables teams to hone in on operational regressions, decreasing the mean time to resolve (MTTR) in the remediation process. Release Guardian provides a proactive safety net for complex product releases, identifying issues with higher sensitivity and introducing observability at the feature level, along with automated incident response.

Migrations often pose a wide swath of issues for engineering teams, particularly in terms of risks relating to data loss. Failed migrations often lead to unplanned downtime, resulting in potential customer churn and lost revenue, along with negative user sentiment stemming from suboptimal experiences.

LaunchDarkly’s Migration Assistant helps organizations structure complex migrations into up to six stages to mitigate risk of outages, data loss, or latency issues between disparate data stores. The Migration Assistant enables developers to use controlled cohort progression in incrementally moving traffic allocation, along with using consistency checks to ensure consistency between old and new data stores. LaunchDarkly’s migration flag is specifically built for integrations, providing out-of-the-box support for migration paths with 2, 4, or 6 stages in providing more predictable migration processes.

Enterprise Scalability

While feature flags may be critical in mitigating post-release firefighting, technical debt may arise as organization-wide feature flags and experimentation accumulate. Feature flags may prove instrumental in streamlining deployments, but maintenance of sustainable feature flagging can devolve into management of flags across disparate paths and nested flags, creating additional complexity by increasing compile and test execution time.

Without regular archival of flags, codebases can become cluttered with flags intended to be temporary, creating extensive flag lists and the risk of old flags defaulting to invalid or undesirable states. To avoid widespread technical debt, any temporary flags with an “inactive” status should be archived, along with any temporary flags that have already been “launched,” or gradually rolled out to intended audiences. Feature management broadly necessitates a wider organizational alignment towards consistent monitoring, maintenance, and archival of relevant flags. Organizations may require longer timelines when transitioning towards canary testing mechanisms along with staged or progressive deployments.

Technical debt also tends to fester over time, hindering application development, performance, and scalability. With increased technical debt, development teams may struggle with higher volumes of software patches, maintenance requirements, restructuring issues, and bug fixes. Adding additional feature flags may complicate testing and management, especially as flags become obsolete or unnecessary. Flag management across teams requires maintenance across development environments spanning local, quality assurance (QA), staging, and production, which can prove difficult given the sheer volume of developers interacting with accumulated flags.

Without a clear governance structure in place, teams may struggle to manage the lifecycle of feature flags. To avoid accumulation of technical debt, teams may need to adopt regular check-ins to ensure that flags are used optimally and retired when deemed obsolete, especially in enterprise application environments. Regular flag reviews on a quarterly or even monthly basis may also help isolate flags that need to be archived. By generating a list of flags that should be cleaned up, teams can parse through their assigned portion of flags to determine whether patch or pull requests are required in eliminating the flag.

End-to-End Solutions

Given the sheer volume of CI/CD tools geared towards feature flagging, LaunchDarkly operates in a realm with end-to-end solutions that span the entire development lifecycle. Harness, for instance, provides coverage across cloud and on-prem projects, leveraging CI/CD along with feature flags, chaos engineering, service reliability management, and engineering insights. For developers seeking an integrated, full-service option, platforms like Harness may be preferable to LaunchDarkly’s point solution, where they may need to construct their own workflows around chosen tools.

Given the availability of alternative feature flag systems, developers may choose other platforms with feature flagging capabilities based on specific functionality included. Harness can be integrated within existing workflow tools such as Jira and Slack, with reusable feature templates across applications. Split offers extensive audit logging and the ability to make changes to features without alerting code, along with analytics for metrics derived from Google Analytics and Sentry. Optimizely similarly supports more advanced feature flagging and the ability to manage all feature flags within a unified interface, along with more control over time and user variables.

LaunchDarkly is a developer-first feature management platform designed to de-risk releases, create targeted experiences, and facilitate product experimentation. Given the complexity of modern development processes, LaunchDarkly has become critical to maintaining stability in software releases, ensuring that developers can consistently test and deploy reliable applications. The platform provides more granular control over feature flags, providing support for feature experimentation, release management, cloud migrations, outage prevention, and load shedding. As LaunchDarkly continues to streamline experimentation AI application development and provide automated release, remediation, and migration assistance, the platform continues to support engineers in the software development lifecycle.