Ship once.
Control forever.
Get results instantly.
AppFig™ gives product and growth teams instant control over in-app user experiences without engineering bottlenecks.
Change what users see, when, and who sees it—all evaluated locally with zero latency. Boost retention, test faster, grow revenue.
Free plan available • No credit card required
Works with Unity, Android, iOS, and React.
"We adjusted ad load and IAP offers in a single day—retention up 8%, ARPDAU up 12%, zero rebuilds. AppFig™ is our growth cockpit."
— VP Product, Mobile Gaming Studio (60K DAU)
What Makes AppFig™ Different
Built specifically for mobile apps and games with behavioral targeting, client-side evaluation, and infinite scale.
World-Class Targeting & Segmentation
Target users by what they actually do: event counts, sequences, parameters, and time windows combined with user & device properties.
- • Event-based logic with count operators & recency
- • Sequential behavior tracking (funnels, onboarding flows)
- • User properties (LTV, tenure, subscription status)
- • Device context (OS, locale, device class)
Experiment-Ready, Analytics-Friendly
Works alongside your existing analytics. Log events to GA4, Amplitude, or Firebase—then use those same events in AppFig™ rules.
- • No analytics lock-in or vendor duplication
- • Same event taxonomy across tools
- • Built for experimentation & A/B testing workflows
Infinite Scale & Performance
CDN-first architecture with immutable rule files and cached pointers. Evaluations run locally on device with ~0ms overhead.
- • Millions of requests served from edge cache
- • 0ms feature checks, no runtime network calls
- • Works offline, sync cadence configurable per plan
Governance for Real Teams
Multi-environment setups and auditability so flags don't become tech debt.
- • Dev / Stage / Prod environments
- • Role-based access via ACL
- • Versioned rules, rename & archive flags safely
More Than Feature Flags
Ship dynamic values, complex payloads, and key/value configs—not just on/off toggles.
- • Numeric & text values for rewards, prices, difficulty
- • JSON payloads for layouts, themes, offers
- • Combine feature flags with advanced config in one place
Advanced Targeting & Segmentation
Build rules based on behavior, properties, and device context — all evaluated instantly on device.
Event-Based Logic
Target users by what they actually do: count of events, parameters, and recency.
- •
count.operator(>=, <, ==, etc.) - • Parameters like
level,country,source - •
within_last_daysfor recency rules
Sequential Behavior
Create funnels like "fail → watch ad → purchase" and trigger features at exactly the right moment.
- • Ordered event sequences
- • Optional steps and time windows
- • Great for onboarding, funnels, and live ops
User Properties
Combine audience traits and cohorts with behavioral targeting.
- • Subscription status, tenure, LTV buckets
- • Segments from MMPs, CRMs, or data warehouses
- • Attribute-based scoring and thresholds
Device & Session Context
Tailor experiences based on device capabilities and live session signals.
- • Locale, OS version, device class, network state
- • Session depth, install age, engagement streaks
- • Perfect for cross-platform launches & seasonal events
Logic Groups & Operators
Nest condition groups and reuse rule fragments with visual logic builders.
- • AND / OR / NOT groupings with depth controls
- • Saved logic blocks for reusable campaigns
- • Preview evaluation paths before shipping
See It In Action
All AppFig™ rules evaluate locally on device — no runtime network calls. Rules sync from CDN on your schedule and work fully offline.
{
"feature": "easy_mode",
"conditions": {
"events": [
{
"key": "level_fail",
"count": { "operator": ">=", "value": 3 }
}
],
"user_properties": [
{
"key": "is_paying_user",
"operator": "!=",
"value": "true"
}
]
},
"value": "on"
}// Set user properties
AppFig.SetUserProperty("subscription", "free");
AppFig.SetUserProperty("player_level", "5");
// Log events (auto-increments count)
AppFig.LogEvent("level_fail");
// Check if easy mode should activate
if (AppFig.IsFeatureEnabled("easy_mode")) {
ShowEasyModeUI();
ReduceDifficulty();
}
// Evaluation: <0.1ms
// No network call • Works offlineWhy Not Just Use X?
Config tools change parameters. AppFig™ changes outcomes.
Traditional flag tools optimize web and backend. AppFig™ is built specifically for mobile apps & games, with client-side behavioral targeting and CDN delivery.
Firebase Remote Config
🔥AppFig™ → Instant event-based rules, zero-latency checks
LaunchDarkly
🚀AppFig™ → Mobile-first, client-side, 10x lighter SDK
Mixpanel
📊AppFig™ → Analytics-powered control in one tool
Split.io
🔀AppFig™ → Experiments + operations, zero tech debt
Build Your Own
🔧AppFig™ → 10-min setup, instant reverts, visual builder
"AppFig replaces delay with decision — every rule evaluated instantly on device."
Feature Comparison
| Feature | AppFig™ | Firebase | LaunchDarkly | Mixpanel | Split.io | Build Own |
|---|---|---|---|---|---|---|
| Evaluation Speed | < 1ms | ~100ms+ | ~50ms+ | N/A | ~50ms+ | Variable |
| SDK Size | ~100KB | 1MB+ | 500KB+ | 800KB+ | 400KB+ | Custom |
| Event-Based Targeting | GA only | Track only | Maybe | |||
| Feature Control | Maybe | |||||
| Mobile SDKs | Unity, React, iOS, Android | Limited | iOS, Android | iOS, Android, React | iOS, Android | Custom |
| Setup Time | 10 mins | 1-2 days | 2-3 days | 1 day | 1-2 days | 3+ months |
| Monthly Cost (Starter) | $99 | $150+ | $200+ | $89+ | $150+ | $15K+ |
*AppFig™ rules evaluate client-side with zero latency. Sync cadence: 1–24 hours (plan-dependent).*
Governance & Team Workflow
Ship safely with multi-environment pipelines, role-based access, and immutable version history that keeps every change auditable.
Multi-Environment Pipelines
Dev, Stage, and Prod each have isolated rule sets, API keys, and deployment approvals.
Role-Based Access
ACL-driven permissions ensure only the right teams can publish, approve, or edit targeting logic.
Flag Lifecycle Management
Rename, archive, or sunset flags with automated dependency checks and usage insights.
Version History & Audit
Immutable rule files with full diff history and rollbacks, plus exportable audit trails for compliance.
Get Results in Minutes
Six ways studios delight users and grow revenue — without rebuilds.
Dynamic Ad Strategy — Monetize Without Churn
Adjust ad frequency, formats, and triggers per user type. Reduce pressure for payers, increase for non-spenders, and A/B test live.
Personalized IAP Offers — Sell Smarter
Target offers by progress, spend intent, or session depth. Run promos instantly.
Difficulty & Flow Tuning — Keep Users in the Zone
Adapt difficulty, hints, and pacing for each cohort.
LiveOps & Seasonal Events — Ship in Hours
Activate themed content or bonuses instantly; automate start/end.
Kill Switch & Risk Control — Protect Ratings
Disable buggy features or bad ad networks immediately.
Acquisition-Aware Onboarding — Turn ROAS into LTV
Personalize onboarding by source.
Built for Live Teams
No-Code Option: Drag & Drop Components
Unlike Remote Config, you can inspect, debug, and test rules locally with zero cloud dependencies.
AppFig™Helper
Strong drop-in component for init & event logging. One GameObject, zero boilerplate.
Easy event logging helpers
AppFig™Applier Component
Drag onto any GameObject. Set feature name. Toggle visibility, update text, or set numeric values. Zero code.
Action: Enable/Disable GameObject
AppFig™ABTester Component
A/B test sprites, colors, materials, prefabs. Define variants. No code required.
Variants: red | blue | green
Copy One File
Drop AppFig™ SDK into your project. That's it. No packages. No dependencies.
10x leaner than Firebase (1MB+)
One-Line Setup with AppFig™Helper
// Drop-in component for init & logging
AppFigHelper.Init("company", "project");
AppFigHelper.LogEvent("level_complete");Strong drop-in helpers for init & event logging.
Check Features Anywhere
if (AppFig.IsFeatureEnabled("promo")) {
ShowPromo();
}
string difficulty =
AppFig.GetFeatureValue("difficulty");Instant check. Works offline.
Built by Developers, Loved by Studios
"AppFig finally lets us move as fast as we think."
— Mobile Game Developer
"LiveOps and monetization in one system — zero rebuilds."
— Indie Developer
"Safer than our custom flags, 10× faster to test ideas."
— Tech Lead, Gaming Studio
"We tweak, we learn, we grow — daily."
— Solo Developer
Pricing That Tracks Outcomes, Not Server Time
No hidden costs. No surprise bills. Predictable growth.
Typical Value Scenarios
Based on industry benchmarks for mobile apps with 50K DAU
- 1 app, 1 seat
- 10 features (local)
- Local-only (no CDN)
- Behavioral targeting
- 99% uptime
- Community support
- No credit card required
- Unlimited apps & seats
- 100 features/configs
- 1 hour polling
- 5 publishes/day, 5 AI queries (soon)/mo Coming Soon
- Standard CDN, 7d history
- 99% uptime, 72h support
- Unlimited apps & seats
- 500 features/configs
- 15 min polling
- 25 publishes/day, 25 AI queries (soon)/mo Coming Soon
- Premium CDN, 14d history
- 99.9% uptime, 48h support
- Unlimited apps & seats
- 1000 features/configs
- 5 min polling
- 50 publishes/day, 50 AI queries (soon)/mo Coming Soon
- Premium CDN, 30d history
- Realtime (add-on)
- 99.95% uptime, 24h support
- Unlimited apps & seats
- 2000 features/configs
- 1 min polling
- 100 publishes/day, 100 AI queries (soon)/mo Coming Soon
- Premium CDN, 90d history
- Realtime included
- 99.99% uptime, dedicated (<6h SLA)
Enterprise-Grade Security & Compliance
Built on Google Cloud Platform with privacy-first architecture
Privacy-First Architecture
All rules evaluate on-device. No user PII sent to servers. Events stay local for evaluation.
- Client-side rule evaluation
- No user tracking or behavioral data collected
- GDPR & CCPA compliant by design
Enterprise Data Security
Built on Google Cloud Platform infrastructure with bank-grade security.
- Encryption in transit (TLS 1.3) and at rest
- Firebase Security Rules & role-based access
- Hashed API keys with rate limiting
Audit Logs & Compliance
Full audit trail and version history for compliance requirements.
- Immutable version history for all changes
- Rollback capability with one click
- SOC 2 Type II infrastructure (Google Cloud)
Enterprise Ready
Legal and compliance documentation for enterprise procurement.
- Data Processing Agreement (DPA) available
- Terms & Privacy Policy
- 99.9% uptime SLA (Growth+)
Every Question Answered
Is this a feature flag tool?
AppFig™ is a live config layer that also sets numeric/text values and targets by events and properties.
How fast are changes applied?
Instantly on device; global sync every 1–24 h.
Need Firebase/GA audiences?
No. Evaluation happens locally.
Privacy?
All rules run client-side; no PII leaves device.
Who uses AppFig™?
Studios and app teams focused on growth, retention, and happier users.
Which platforms have SDKs?
Unity, React, Android (Kotlin), and iOS (Swift). All SDKs are production-ready. Unity SDK works on all Unity-supported platforms: iOS, Android, Windows, macOS, Linux, WebGL. We're Unity-first but support all major mobile and web platforms.
Can I migrate from Firebase Remote Config?
Yes, easily. Rules map 1:1 with Firebase parameters. SDK integration takes 10 minutes. We'll help you migrate. Most teams run both in parallel for a week, then fully switch to AppFig.
Do I need a backend?
No. That's the whole point. Drop in the SDK with AppFig™Helper for one-line init & event logging. No servers to manage, no backend engineering needed. AppFig™ delivers rules from CDN, SDK evaluates them client-side.
What about emergency kill switches? Don't most apps have these?
True, but AppFig™ is more than kill switches. Yes, basic kill switches are common. AppFig™ enables adaptive user experiences—dynamic difficulty, personalized content, targeted promos, gradual rollouts, A/B testing, regional features. It's about treating each user better to boost retention and engagement, not just emergency controls.
Does AppFig™ work with native mobile apps?
Yes. We have native SDKs for Android (Kotlin) and iOS (Swift), plus Unity and React. Whether you're building native mobile, cross-platform with Unity, or web apps with React, AppFig™ has you covered with the same powerful client-side evaluation engine.
How fast do rule updates apply?
Configurable: 1 minute to 24 hours. Updates propagate globally via CDN. SDK auto-refreshes on your schedule (defaults: 12hr for production, 24hr for optimal efficiency, configurable from 1min to 24hr). Emergency kill switches can apply in 1-2 minutes if configured for frequent syncs. Balance freshness with bandwidth.
Can I use AppFig™ with my existing analytics?
Yes. AppFig™ works alongside Firebase Analytics, GA4, Amplitude, Mixpanel, or custom pipelines. We don't replace your analytics. We just make features dynamic based on user behavior you're already tracking.
Can AppFig™ replace Google Analytics?
No, it complements it. AppFig™ is for feature flags and dynamic configuration, not analytics. It logs events locally for rule evaluation, but doesn't replace your analytics platform. Use AppFig™ with GA4, Firebase Analytics, or any other analytics solution.
Stay Updated
Join developers building better apps. Get tips, updates, and early access to new features.
No spam. Unsubscribe anytime.
Control What Happens Next
Ship once, control forever. Move faster, delight users, and grow revenue instantly.
Move faster → Delight users → Grow revenue