This article covers the following:
Understanding the Wingify Feature Experimentation Workflow
This article explains how Wingify Feature Experimentation works in practice. It covers the core concepts and workflow involved in setting up and running feature experiments.
Note: Feature Experimentation works through SDK and code-level implementations. As a result, engineering support is required for integration, experiment setup, and ongoing management.
Wingify Feature Experimentation follows a three-phase model that separates configuration from implementation, allowing teams to plan, control, and measure feature releases before writing or changing code.
The three distinct phases involve:
- Configuration in the Wingify application
- Implementation in your application's codebase
- Launch and Monitoring
Phase 1: Configuration in the Wingify application
In the Wingify application, you define what the feature is, who should see it, and how its impact will be measured.
This includes:
- Creating a feature flag to act as the on/off switch
- Defining configurable variables for dynamic behavior
- Setting up variations to support experimentation
- Choosing metrics to measure success
- Applying rules to control rollout, testing, or personalization
This phase focuses on control, targeting, and measurement, all without touching your codebase.
Phase 2: Implementation in your application’s codebase
After a feature flag is configured in the Wingify application, engineering teams integrate the Wingify SDK into their application once and add flag checks in the code where the feature logic needs to be controlled.
From this point onward, the application code and Wingify configuration work together, but serve different roles:
- Configuration lives in Wingify: Feature flags, targeting rules, variations, and rollout logic are defined and managed in the Wingify application.
- Business logic lives in your application: The application contains the feature logic and calls the SDK to determine which behavior to execute.
- Decisions happen at runtime: The SDK evaluates the configured rules and returns the appropriate variation for each user.
At runtime, the SDK evaluates feature rules locally within the application. Because the decision is made within the application itself, there is no network call required to determine the experience, ensuring consistent performance even in high-traffic environments.
Based on the evaluation result, the application serves the appropriate experience to the user, such as:
- A new feature being enabled
- A specific experiment variation
- The default application behavior
This implementation separates feature control from application deployment. Product and engineering teams can safely adjust targeting rules, update rollout percentages, or disable features directly from Wingify without modifying application code or initiating a new release cycle. Because decisions are evaluated locally and deterministically, the same user will consistently receive the same experience across requests, ensuring reliable experimentation and feature rollouts at scale.
For detailed implementation guidance, see Getting Started with FE and Implementation.
Phase 3: Launch and Monitoring
After implementation, you can manage feature behavior directly from the Wingify application. Teams can control who sees the feature, which variation is served, and when it is enabled, without requiring additional code changes or redeployments.
Based on the targeting rules, the appropriate experience is served to each user, such as a specific variation, a new feature, or the default behavior. This setup allows product and engineering teams to safely control feature exposure, adjust rollout percentages, update configurations, or disable features when needed, all without going through a new release cycle.
Supported SDKs & Integrations
Wingify FE supports a wide range of server-side, client-side, and mobile SDKs to cater to different development environments. For a complete list of supported SDKs and their specific implementation guides, refer to the List of Supported Wingify FE SDKs.
Additionally, it integrates with various third-party tools to help you analyze feature impact across your stack. You can connect to data warehouses, Customer Data Platforms (CDPs), analytics, and observability tools. For more information, see Wingify Integrations.
Attention: Ensure your development team verifies the eligibility and compatibility of the specific SDK with your technology stack before implementation.
To get started with implementation, see:
Need more help?
For further assistance or more information, contact Wingify Support.