SDLC, Launchdarkly feature flag

1. Feature Flag!

2. Agenda:
● Why we need feature Flag?
● What are Feature Flags?
● Feature Flag in Continuous Delivery
● Basic Feature Flag in App
● Advance Feature Flag
● Maintenance and Best Practice
● Case Study

3. Why we need feature Flag?
● Can’t release a broken feature in progress
● Don’t want to delay release of other features that
are ready
Solution is : Decoupling Feature rollout from code deployment

4. Feature Flag
New Feature
OLD Feature

5. Feature Flag
newThemeForBrandSite = false
If (newThemeForBrandSite) {
showNewThemeForBrandSite()
} else {
showOldThemeForBrandSite()
}

6. Feature Flag and SDLC

7. The Traditional SDLC

8. The Traditional SDLC with Feature Flag

9. Basic Feature Flag in APP
Implementation

10. Application Configuration File
app-flags.config
newThemeForBrandSite = false
newComponent01 = false
newLandingPage = true

11. Implementation of the App Config
Import appFlgas from ‘app-flags.config’;
Import newLandingPage from ‘newLandingPage’;
Import oldLandingPage from ‘oldLandingPage’;
class App extends React.Component {
render() {
return If (appFlgas.newThemeForBrandSite) {
newLandingPage()
} else {
oldLandingPage()
}
}
}

12. Deploy Updated Feature Flag
● Create new build for updated Feature Flag
● Test new flag in all the environment
● Deploy new build.

13. Advance Feature Flag

15. LaunchDarkly Flags for Modern Development
These aren't your old school, run of the mill on/off feature flags. LaunchDarkly feature flags
are cross-platform supported, multi-lingual and updates are delivered consistently across
all your services in real-time, without introducing any latency to your site.

16. Features
Stored Locally
After our SDK initializes, all your feature flag rules are stored locally in memory. This allows you to process
millions of evaluations, without introducing latency in your services, since you don't have to run a query
against a separate database or call back to LaunchDarkly at the time of a flag evaluation. You can even add
an additional layer of reliability by using one of our local storage options with our SDKs.
Real-time Updates
Our unique streaming architecture means you can instantly turn features on/off when you need to without
introducing any latency to your site. It only takes 200 milliseconds to propagate flag updates.
Incremental Rollout : you can rollout new features incrementally for few random users.
Targeting Individual users: you can release new feature to only specific user.

17. Oversight & Control
Feature flagging is not a new concept. For decades
development teams have utilized feature flags to control
the release of new features to their end users. Starting to
feature flag isn't hard, but managing feature flags at scale
with granular control over who sees what is. Our real-time
feature flags give you the confidence to ship code faster
without the worry of severely impacting your users.

18. Intuitive UI
Our easy-to-use user interface puts the power of feature flags into anyones hands, not just
developers. Less technical stakeholders from product, marketing or client services can now
play a role in your feature management practices without fear of them causing a product
incident.
Access Controls
Create flexible policies that provide fine-grained access controls to anything in LaunchDarkly
from feature flags to A/B testing. Custom roles reduce the burden on development teams by
sharing feature release capabilities with less technical stakeholders.
Audit Log
Gain critical insights on all the changes made throughout your environments including who
made changes, when and the specific code that was updated.

19. Centralized Dashboard
View and manage all your feature flags across
every environment and project all in one central
spot. Our platform provides the cross team visibility
needed to implement feature management
practices at scale without introducing costly
technical debt.

20. Implementation
Get code from github and replace keyId with yours
https://github.com/Sandeep821/FetaureF
lagLaunchDarklyForReact

21. Maintenance and Best Practice

22. Maintenance and Best Practice
● Track your Feature Flags
● Maintain/cleanup Feature Flags
● Setup Alert/Notification

23. Case Study

24. Atlassian Timeline
Challenge
A few teams within Atlassian used an internally-built feature flagging system. It was primarily used to control feature releases,
and with this system, deployments were also tied to releases. This proved sufficient at first but, but as more teams wanted to
use this in-house solution, some challenges arose: the system took time and resources to maintain. Different teams working
with different languages needed help developing their own Software Development Kits (SDKs). And with no interface, this
system was virtually unusable for non-technical users. The result was that teams outside of engineering, including Product
Management, relied on engineering support to turn features on/off or run beta tests, which became unruly when more teams
wanted to use the solution.
Solution
With LaunchDarkly, more and more teams across the organization now have the ability to separate code deployments from
feature releases. The first team to adopt LaunchDarkly was able to get started pretty quickly. SDKs are standardized, well
maintained, and available in all major languages, so developers can setup LaunchDarkly in their stack in a matter of
minutes. In the months following, other teams started using LaunchDarkly. For the first time, teams had visibility into their
feature flags from a central location. When developers begin to build a feature, they simply wrap it in a flag, and then control
it from the LaunchDarkly dashboard. This means teams can ship code at any time with flags turned off and features hidden,
and then turn the features on when they’re ready.
Teams also have better control over segmenting their user base. Instead of switching something on/off for everyone, they
now build cohorts and expose different groups to different features in a highly targeted fashion. Teams are now testing,
getting feedback, and iterating while working through projects without having the changes dependent upon each other.