Great Features, but Integration Needs Improvement
What do you like best about the product?
One thing I like about LaunchDarkly is the ability to let certain customers use certain features while others do not.
What do you dislike about the product?
One of the major issues is that we're adding a lot of flags for many different companies and projects, but we have no way of integrating the company IDs and the project IDs with LaunchDarkly. So we kinda have to find them and manually add them. It would be better if we could select the LaunchDarkly flags with checkboxes and then automatically pick a company or project, enabling or sending it for approval instead of doing everything manually. The process is very manual at the moment, making it tedious, which affects how likely I would recommend it.
What problems is the product solving and how is that benefiting you?
I use LaunchDarkly to add features to specific customers and projects for testing, ensuring most customers aren't affected during trials.
Seamless Feature Management with LaunchDarkly
What do you like best about the product?
I appreciate how LaunchDarkly lets us differentiate between which models we serve to different customers. It allows us to transition seamlessly and smoothly whenever we have to do more complex migrations, enabling us to transition customers individually. I also value the bulk edits feature.
What do you dislike about the product?
More advanced bulk edits are not included in the standard paid plan.
What problems is the product solving and how is that benefiting you?
I use LaunchDarkly to gate certain features with feature flags, manage customer models, and transition smoothly during complex migrations.
LaunchDarkly Makes Feature Releases Safer with Powerful Flag Management and Integrations
What do you like best about the product?
Overall great Experience but some highlights are ,
LaunchDarkly: A Comprehensive Review
Here’s a detailed breakdown of LaunchDarkly's key aspects, focusing on the features and benefits that users most frequently highlight.
UI / UX: Intuitive and Empowering
One of the most consistently praised aspects of LaunchDarkly is its user interface. Instead of just being "easy to use," the platform's design has a direct impact on workflow efficiency.
Centralized Flag Management: The main dashboard provides a single source of truth for all feature flags. This clarity is invaluable in a complex microservices architecture where tracking feature states could otherwise be a nightmare. For example, a developer can instantly see that the "new-checkout-flow" is active for 5% of users in the UK, while the "beta-reporting-engine" is only on for internal staff. This eliminates ambiguity and the need to dig through code or config files.
Targeting and Segmentation: The user targeting rules engine is incredibly powerful yet simple to operate. You can create complex segments with a few clicks. For instance, you could roll out a new feature to "users in Germany on an iOS device who are part of the 'Pro' subscription tier." This granularity allows for precise, safe testing and reduces the risk associated with big-bang releases.
Toggle and Flag Status Visibility: The visual toggles and clear status indicators (e.g., "Active," "Inactive," "Launched") mean that even non-technical team members, like product managers or marketers, can understand the state of a feature and even control its release. This democratizes the release process and frees up engineering resources.
Integrations: A Connected Workflow
LaunchDarkly's value is significantly amplified by its extensive ecosystem of integrations, which embed feature flagging directly into the existing development lifecycle.
CI/CD and Code Repositories: Integrations with tools like Jira, GitHub, and Slack create a seamless feedback loop. A practical example is creating a Jira ticket that automatically generates a corresponding feature flag in LaunchDarkly. When a pull request is merged in GitHub, the flag can be automatically enabled in a staging environment.
APM and Observability: The integrations with platforms like Datadog, New Relic, and Dynatrace are a game-changer for performance monitoring. When a new feature is rolled out, you can overlay LaunchDarkly events (like "flag turned on") onto your performance graphs. If you see a spike in latency or errors that coincides perfectly with a feature release, you can immediately disable the flag with a single click in Launch_Darkly, effectively "killing" the problematic feature without a frantic rollback or hotfix deployment.
Unexpected Benefit: The Slack integration provides more than just notifications. It allows teams to manage flags directly from a Slack channel. For instance, during an incident, an engineer could type a command like /ld-kill-flag production new-api-integration to immediately mitigate an issue without ever leaving the incident response channel.
Performance: Negligible Overhead
A common concern with any third-party SDK is performance overhead. LaunchDarkly is engineered to minimize this.
Streaming Architecture: Instead of making a remote call for every flag evaluation, the LaunchDarkly SDKs establish a streaming connection (Server-Sent Events) to receive flag updates. This means that once the initial connection is made, all flag evaluations are performed in-memory at near-zero latency. For a high-traffic e-commerce site, this ensures that the user experience is not degraded by waiting for a feature flag service to respond.
Resilience and Fallbacks: The SDKs are designed with resilience in mind. If the connection to LaunchDarkly's servers is ever lost, the SDK will continue to serve the last known set of flag values. This ensures that your application continues to function predictably, even in the event of a network partition or an issue with LaunchDarkly's service.
Pricing / ROI: From Cost to Investment
While LaunchDarkly is a premium product, the return on investment is often justified by risk reduction and increased development velocity.
Decoupled Deploy and Release: The core value proposition is the ability to decouple code deployment from feature release. This means developers can merge and deploy code to production continuously, even if the features aren't ready for users. The code sits dormant behind a flag. This eliminates the stress and risk of "big bang" release days. The ROI here is measured in reduced deployment-related incidents, fewer rollbacks, and less developer time spent on managing complex branching strategies.
Saved Engineering Hours: Consider the time it takes to build a robust, in-house feature flagging system with a user-friendly UI, audit logs, and complex targeting rules. This is a significant engineering effort. By using LaunchDarkly, that time is instead spent on building core product features that deliver direct value to customers. The subscription cost is often a fraction of the cost of the engineering salaries that would be required to build and maintain a comparable internal solution.
Support / Onboarding: A True Partnership
Users frequently report positive experiences with LaunchDarkly's support and documentation.
Comprehensive Documentation: The developer documentation is clear, with copy-and-paste examples for every supported language and framework. This drastically reduces the time to get started. A developer can typically have the SDK integrated and their first feature flag operational within an hour.
Responsive and Knowledgeable Support: When issues do arise, support is noted to be responsive and staffed by engineers who understand the product deeply. This is a significant step up from basic first-line support and is crucial when dealing with a service that is so integral to the production environment.
AI / Intelligence: The Future of Flagging
LaunchDarkly is beginning to incorporate intelligence into its platform to move from reactive to proactive feature management.
Experimentation and A/B Testing: The platform's experimentation features allow you to tie feature flags to business metrics. For example, you can roll out a new "Add to Cart" button design to 10% of users and measure its impact on the conversion rate compared to the old design. The platform handles the statistical analysis and tells you if the new feature is a winner, a loser, or inconclusive.
Future Direction: While not fully "AI" in the generative sense, the direction is towards intelligent automation. This includes features that can automatically detect performance regressions caused by a feature release and potentially even automatically disable the flag. This moves towards a self-healing system where the platform itself helps ensure application stability.
What do you dislike about the product?
Nothing so far—everything looks good to me.
What problems is the product solving and how is that benefiting you?
Problem 1: Risky, Stressful, All-or-Nothing Releases
Traditional “release day” tends to be a high-stakes, high-stress event. A huge batch of new code goes live at once, and if anything breaks, it turns into a frantic scramble to roll back, which can mean downtime and frustrated engineers.
LaunchDarkly’s Solution: It decouples code deployment from feature release. Your team can continuously deploy code to production servers, while the new functionality stays dormant behind a feature flag. The feature only becomes visible to users when you flip the switch in the LaunchDarkly dashboard.
How That Benefits You:
Fearless Deployments: You can deploy code on a Tuesday afternoon with confidence, knowing it won’t affect users until you’re ready. This removes much of the stress and ceremony around “release day.”
Instant Rollbacks (Kill Switch): If a feature causes a bug or performance issue after release, you don’t need to redeploy or roll back code. You simply flip the flag off. Your Mean Time To Recovery (MTTR) drops from hours to seconds, giving you a strong safety net.
Problem 2: Slow Development Velocity and “Merge Hell”
Long-lived feature branches are a common bottleneck. They’re hard to merge, they delay feedback, and they make parallel work more difficult, which slows the whole team down.
LaunchDarkly’s Solution: It supports Trunk-Based Development. Developers can merge small, incomplete pieces of work into the main codebase (the “trunk”) every day, with those changes safely wrapped in a feature flag.
How That Benefits You:
Increased Development Speed: Features reach a “done” state faster because the team integrates continuously, instead of dealing with the painful merge of a massive, month-old branch.
Improved Code Quality: Small, frequent merges are easier to review and test, which helps reduce the number of bugs introduced into the main branch.
Problem 3: The Gap Between Staging and Production
Even with a strong staging environment, it rarely matches the scale, data, and messy reality of production. As a result, some issues only show up after you’ve released to real users.
LaunchDarkly’s Solution: It enables safer testing in production. You can expose a new, higher-risk feature to a tiny, controlled audience—such as the internal engineering team, a single test account, or 1% of your user base.
How That Benefits You:
Ultimate Confidence: You can validate that a feature works with real production data and infrastructure without putting all users at risk. You catch “production-only” bugs when they can affect only a handful of people (or just you).
Example: You can roll out a new database query or API integration to your internal team first. If it performs well under real-world conditions, you can progressively expand the audience with confidence.
Problem 4: Making Business Decisions Based on Guesses
You ship a feature you believe will improve engagement or conversion, but without a solid testing framework, it’s hard to know whether it actually helped. In that situation, you’re essentially guessing about the business impact of engineering work.
LaunchDarkly’s Solution: The Experimentation framework. You can wrap different versions of a feature in flags, assign them to different user groups, and tie the rollout to a key business metric (e.g., “add to cart” clicks, time on page, subscription sign-ups).
How That Benefits You:
Data-Driven Decisions: You can move from “we think this is better” to “we have proven this new checkout flow increases conversion by 8%.” That makes it possible to measure the ROI of development efforts objectively.
Product-Engineering Alignment: It creates a shared language between product managers and engineers. The focus shifts from simply shipping code to improving key business metrics, helping ensure the team is working on what delivers the most value.
Managing complex feature flags has demanded heavy infrastructure effort but has enabled safer rollouts
What is our primary use case?
My main use case for LaunchDarkly is that my company uses it for feature flags and experimentation, and for my team specifically, I work in the platform team, managing the infrastructure to support LaunchDarkly.
A quick, specific example of how my team uses LaunchDarkly for feature flags or experimentation is a basic use case where we have an API and a feature flag to turn on new features, and for experimentation, we test out the features to a subset of customers before releasing it to everyone.
What is most valuable?
The best feature LaunchDarkly offers is the capability of having a feature flag that we don't have to build in-house.
LaunchDarkly has impacted our organization positively by giving us a feature flag and experimentation capability, which we didn't have beforehand.
What needs improvement?
It seems to be quite expensive for what you get, and for my team specifically, where we manage the infrastructure for LaunchDarkly, it seems overcomplicated and very hard to maintain as we have to deploy a custom component that we host internally, which seems odd for a SaaS product.
To be honest, I don't think there's much time saved overall for Seek based on the overhead of having to maintain the infrastructure internally regarding the value of having this capability without building it in-house.
The documentation online on how to use LaunchDarkly in your SDKs is not great; it's too broad and not specific enough.
LaunchDarkly could be improved by making it cheaper and also reducing the overhead of having to maintain our own infrastructure internally because that really completely defeats the purpose of using a SaaS provider. When you look at the overall seat costs, the engineer time required to manage this infrastructure internally is nontrivial and already I believe it exceeds the benefit in terms of license cost; we may as well have just built our own.
For the documentation, it would be very good to have clear examples of which pattern of LaunchDarkly to use in what use case; for example, when to use the feature store only, when to use the feature store with the persistent store, and when to use the big segments, as it causes a lot of confusion for our internal users. When I say users, I mean our developers using the SDKs, and it's very difficult to point them to which pattern to use. Each of these patterns means a different type of infrastructure that we need to maintain with the relay proxy, which is all very complicated for such a simple use case.
For how long have I used the solution?
I have been using LaunchDarkly for about two years.
What do I think about the stability of the solution?
LaunchDarkly is probably stable, but it's unclear in terms of the stability of the infrastructure that we have to run internally; there are a lot of moving parts that we have to ensure are stable, otherwise LaunchDarkly becomes unusable. While using a SaaS provider, we still have to do all the heavy lifting in-house to put in the monitoring, the SRE, and alerting, which seems overkill for using a SaaS.
What do I think about the scalability of the solution?
The scalability of LaunchDarkly is not great because we have to scale internally with the infrastructure that we deploy.
How are customer service and support?
The customer support is average compared to other vendors; it's not as responsive as I would expect.
Which solution did I use previously and why did I switch?
Previously, we used an in-house built solution, and the idea was our teams that wanted to use the features of LaunchDarkly around experimentation didn't want to build their own.
How was the initial setup?
We did not purchase LaunchDarkly through the AWS Marketplace; it was through direct negotiations with the vendor.
What was our ROI?
I don't see any return on investment; I work in the platform team that has to manage the LaunchDarkly infrastructure, and I can't really see any return on investment. We've burnt at least four quarters of effort to get it running and running effectively.
What's my experience with pricing, setup cost, and licensing?
My experience with pricing, setup cost, and licensing is that I wasn't directly involved in pricing, so I have no visibility on that, but I do know from what I've been told that it is very expensive.
What other advice do I have?
My advice to others looking into using LaunchDarkly is to carefully assess not just the features like using it as a SaaS, but also the tax that you have to pay by having to run your own internal infrastructure, i.e., the relay proxy, to actually get it working effectively. That is nontrivial, and for a SaaS, I expect this to be all out of the box and not something we have to deploy internally.
If I had to go back in time, I would not choose this product. My review rating for this product is five.
Which deployment model are you using for this solution?
Private Cloud
If public cloud, private cloud, or hybrid cloud, which cloud provider do you use?
Quick Feature Management, Needs UX Improvements
What do you like best about the product?
I like how quick LaunchDarkly is to reflect changes, which makes testing easier and quicker. The initial setup was pretty easy.
What do you dislike about the product?
- Downtimes often take down the entire app. - The dashboard seems a little confusing when configuring the flags.
What problems is the product solving and how is that benefiting you?
I use LaunchDarkly to easily switch on/off problematic features and release features selectively, making testing faster.
Effortless Feature Management with LaunchDarkly
What do you like best about the product?
I really like LaunchDarkly because it's very, very easy to use. We can accomplish a lot with just a few clicks. It allows us to ship faster, creating a new feature flag quickly and enabling or disabling it based on different rules without affecting everyone. This speed and efficiency are truly valuable. The initial setup was very quick and straightforward thanks to the solid documentation, which makes deploying on both the front end and back end very fast and without too much trouble.
What do you dislike about the product?
It can get a little expensive
What problems is the product solving and how is that benefiting you?
I use LaunchDarkly to manage feature flags, allowing us to ship production-ready features without affecting users. It simplifies toggling features, offers granular control, and helps us deploy quickly with a few clicks, ensuring fast feature rollouts tailored to select users.
Effortless Feature Management with LaunchDarkly
What do you like best about the product?
I like how LaunchDarkly helps with production releases. We can just flip a flag and release a new feature to a beta group or to everyone. If there is an issue, we can easily just turn the flag off to hide the feature. I also find the UI easy to use, and it's clear what the state of the flag means and what environment I am applying the flag change to.
What do you dislike about the product?
Not much. I only use it for feature flags though.
What problems is the product solving and how is that benefiting you?
LaunchDarkly helps with production releases by allowing us to flip a flag and release features to a beta group or everyone. Issues can be managed easily by turning the flag off to hide the feature.
Easy LaunchDarkly Implementation with Reliable, Intuitive Feature Flag Management
What do you like best about the product?
What I like best about LaunchDarkly is how easy it was to implement in our system. We can manage feature flags consistently across both backend and frontend use cases, which made adoption straightforward for our team.
It is also fairly easy to use once set up. Defining targeting rules for specific contexts, such as project-specific configurations or user segments, is intuitive and gives us good control over gradual rollouts and experiments.
From a performance perspective, we have not noticed any issues. The feature flag evaluation has been reliable and has not introduced any visible impact on our application experience.
What do you dislike about the product?
At first, learning how to set up the targeting rules can be a bit challenging.
What problems is the product solving and how is that benefiting you?
We get an easy to use feature flag management tool, which allows us to easily run expermients with customers to get early feedback.
Target Individuals and Progressive Rollouts That Make Feature Flags Easier
What do you like best about the product?
I like the target individual section. And the progressive rollout functionality, even though it's not super polished
What do you dislike about the product?
We can not use custom rules because we have to make sure that user and organization IDs are matched. For example, we can not match a user on a flag by their name because we can not guarantee that the name will be part of the metadata at all times. The target individual section helps with this, but it doesn't always propagate with all of the information, so sometimes, if it's a newly created account, for example, we can not find it there. We'll have to trust that the ID is right.
What problems is the product solving and how is that benefiting you?
We're using it to handle feature flags mainly. It's great for us because we can turn on and off features for our clients. For better or worse, we use it as a sort of management tool rather than a pure roll-out tool.
Seamless Feature Rollouts with Effortless Segmentation
What do you like best about the product?
I like using LaunchDarkly to roll out features in phases and being able to test them on specific accounts. The ability to create segments is really handy because it allows me to create a data set and use it in rules at multiple places, which means I don't have to manually add rules every time. Instead, I can just add an existing segment. The initial setup was very easy as well; I was able to create the flag in the UI and quickly implement it within our code.
What do you dislike about the product?
Nothing, everything works great
What problems is the product solving and how is that benefiting you?
I use LaunchDarkly to roll out features in phases and test accounts first. Creating segments helps us reuse rules without manually adding them each time.
