LaunchDarkly + GitHub
Connect LaunchDarkly and GitHub to Automate Feature Flag Workflows
Tie feature flag changes to code deployments, pull requests, and repository events so your development and release management actually stay in sync.
Why integrate LaunchDarkly and GitHub?
LaunchDarkly controls what's live. GitHub manages the code that got it there. When these two systems don't talk to each other, teams lose track of which flags correspond to which code changes — and that gap creates release risk and a lot of manual overhead. Connecting LaunchDarkly with GitHub through tray.ai automates the handoff between feature flag management and source control, giving you traceable release workflows without the coordination tax.
Automate & integrate LaunchDarkly & GitHub
Use case
Automatically Enable Feature Flags on PR Merge
When a pull request targeting a release branch merges in GitHub, tray.ai can automatically enable the corresponding LaunchDarkly feature flag in a target environment. No more manually flipping flags after deployment — features go live exactly when the code does.
Use case
Create GitHub Issues When Feature Flags Are Going Stale
Long-lived feature flags pile up technical debt fast. tray.ai can monitor LaunchDarkly for flags that have exceeded an age threshold or are permanently enabled, then open a GitHub issue assigned to the flag's owner with remediation guidance. Teams stay on top of flag hygiene without running manual audits.
Use case
Post Feature Flag Status as GitHub Commit Statuses
tray.ai can listen for flag change events in LaunchDarkly and update the corresponding GitHub commit status to reflect whether the associated feature is enabled, in rollout, or disabled. Any developer reviewing a commit gets instant context on the live flag state tied to that code.
Use case
Roll Back LaunchDarkly Flags When a GitHub Deployment Fails
When a GitHub Actions deployment workflow fails or a deployment environment reports an unhealthy status, tray.ai can immediately disable or roll back the associated LaunchDarkly feature flag to protect users. This automated safety net cuts mean time to recovery without requiring on-call engineers to step in manually.
Use case
Sync GitHub Repository Tags to LaunchDarkly Flag Metadata
When a new release tag is created in GitHub, tray.ai can update the metadata on related LaunchDarkly feature flags to associate them with that release version. You end up with a living record of which flags shipped with which release — useful for audits and retrospectives alike.
Use case
Notify Teams in GitHub Discussions When Flag Targeting Rules Change
When LaunchDarkly targeting rules change significantly — say, expanding a flag rollout to 100% of users or modifying segment targeting — tray.ai can automatically post a comment or discussion in the relevant GitHub repository. Engineering, QA, and product stakeholders stay in the loop without watching LaunchDarkly directly.
Use case
Archive LaunchDarkly Flags When Feature Code Is Deleted from GitHub
When a branch or file containing a feature flag reference is deleted from GitHub, tray.ai can trigger an archival or deprecation workflow in LaunchDarkly for the corresponding flag. Both systems stay in sync, and orphaned flags stop cluttering your flag management dashboard.
Get started with LaunchDarkly & GitHub integration today
LaunchDarkly & GitHub Challenges
What challenges are there when working with LaunchDarkly & GitHub and how will using Tray.ai help?
Challenge
Mapping Feature Flag Keys to Pull Requests Reliably
Feature flag keys in LaunchDarkly and PR identifiers in GitHub follow different naming conventions, and there's no native shared identifier between them. Without a solid mapping strategy, automation breaks or relies on brittle string parsing.
How Tray.ai Can Help:
tray.ai's data mapper and conditional logic operators let teams define custom mapping rules — extracting flag keys from PR descriptions, branch names, or custom labels — without writing bespoke code. The mapping logic lives in the workflow and can be updated without engineering effort.
Challenge
Handling Environment-Specific Flag State Across Multiple GitHub Environments
GitHub deployment environments (staging, production, canary) map to different LaunchDarkly environments, and toggling the right flag in the right environment is easy to misconfigure when done manually.
How Tray.ai Can Help:
tray.ai workflows support branching logic and environment variable substitution, so a single workflow template can dynamically resolve the correct LaunchDarkly environment based on the GitHub deployment target. You configure the mappings once and they apply consistently on every run.
Challenge
Managing High-Volume Flag Change Events Without Noise
Active LaunchDarkly projects can generate dozens of flag change events per day. Reacting to every one of them would flood GitHub with issues, comments, and status updates — which quickly trains engineers to ignore them.
How Tray.ai Can Help:
tray.ai supports event filtering, deduplication logic, and configurable throttling within workflows. Teams decide which flag types, environments, or change magnitudes warrant a GitHub action, so only meaningful events trigger downstream activity.
Challenge
Maintaining Audit Trails Across Two Separate Audit Logs
LaunchDarkly has its own audit log and GitHub has repository event logs, but there's no unified view linking flag changes to their originating commits and pull requests. That gap makes compliance and incident investigation harder than it needs to be.
How Tray.ai Can Help:
tray.ai workflows automatically write cross-system event metadata to both platforms as they run — posting LaunchDarkly change details as GitHub commit statuses or PR comments — so you get a distributed but traceable audit record. You can also route this data to a warehouse for unified reporting.
Challenge
Keeping Integrations Resilient When API Rate Limits Are Hit
Both the GitHub API and the LaunchDarkly API enforce rate limits, and high-frequency workflows triggered by webhooks can exhaust those limits during peak CI/CD activity, causing missed events or incomplete automation.
How Tray.ai Can Help:
tray.ai's workflow engine has built-in retry logic, exponential backoff, and error handling branches that deal gracefully with rate limit responses from both GitHub and LaunchDarkly. Failed steps retry automatically, and you can configure alert notifications for persistent failures that need a human to look at them.
Start using our pre-built LaunchDarkly & GitHub templates today
Start from scratch or use one of our pre-built LaunchDarkly & GitHub templates to quickly solve your most common use cases.
LaunchDarkly & GitHub Templates
Find pre-built LaunchDarkly & GitHub solutions for common use cases
Template
Merge PR → Enable LaunchDarkly Feature Flag
Monitors GitHub for merged pull requests matching a naming convention or label, automatically enables the corresponding LaunchDarkly feature flag in the specified environment, and posts a confirmation comment back to the PR.
Steps:
- Trigger on GitHub pull request merged event matching a defined label or branch pattern
- Extract the feature flag key from PR title, description, or custom field
- Call LaunchDarkly API to enable the matching flag in the target environment
- Post a GitHub PR comment confirming the flag has been enabled with a direct LaunchDarkly link
Connectors Used: GitHub, LaunchDarkly
Template
LaunchDarkly Flag Rollback on GitHub Deployment Failure
Listens for failed deployment status events in GitHub, automatically finds and disables the associated LaunchDarkly feature flag, then opens a GitHub issue documenting the incident and the rollback action taken.
Steps:
- Trigger on GitHub deployment status event with a failure or error state
- Resolve the related LaunchDarkly feature flag key from deployment metadata or environment variables
- Call LaunchDarkly API to disable or revert the flag to its previous state
- Create a GitHub issue in the repository documenting the failure and automated rollback
Connectors Used: GitHub, LaunchDarkly
Template
Stale Flag Detector → GitHub Issue Creator
Runs on a schedule to query LaunchDarkly for feature flags that have exceeded a configurable staleness threshold, then opens a labeled GitHub issue in the relevant repository and assigns it to the flag's maintainer for cleanup.
Steps:
- Schedule trigger fires on a weekly or configurable cadence
- Query LaunchDarkly API for all flags filtered by age, environment status, or last-modified date
- For each stale flag, create a GitHub issue with flag details, age, and cleanup instructions
- Apply a configurable label and assign the issue to the team or individual responsible for the flag
Connectors Used: LaunchDarkly, GitHub
Template
GitHub Release Tag → Update LaunchDarkly Flag Metadata
When a new release tag is pushed to GitHub, this template automatically updates the version metadata on all LaunchDarkly flags associated with that release, keeping release-to-flag traceability accurate across both platforms.
Steps:
- Trigger on GitHub push event for tags matching a semantic versioning pattern
- Retrieve the list of LaunchDarkly flags tagged with the corresponding release milestone or project label
- Patch each flag's metadata in LaunchDarkly to include the new release version tag
- Log a summary of updated flags as a GitHub release note or comment
Connectors Used: GitHub, LaunchDarkly
Template
LaunchDarkly Flag Change → GitHub Commit Status Update
Listens for feature flag change events in LaunchDarkly and maps those changes back to the associated GitHub commit, updating the commit status to reflect the current flag state so developers always have flag context inside GitHub.
Steps:
- Trigger on LaunchDarkly webhook event for flag update or targeting rule change
- Extract the associated commit SHA from flag metadata or a mapped data store
- Call the GitHub Statuses API to post the current flag state as a commit status with context and description
- Optionally post a PR comment if an open pull request is linked to the commit
Connectors Used: LaunchDarkly, GitHub
Template
Scheduled LaunchDarkly Flag Audit Report to GitHub
Generates a periodic audit report of all active LaunchDarkly feature flags and their targeting rules, then commits the report as a markdown file to a designated GitHub repository for version-controlled compliance documentation.
Steps:
- Schedule trigger fires on a monthly or compliance-driven cadence
- Query LaunchDarkly API to retrieve all flags across specified projects and environments
- Format flag names, states, targeting rules, and owner data into a structured markdown report
- Commit the markdown report to a designated GitHub repository with a timestamped filename
Connectors Used: LaunchDarkly, GitHub