Frequently Asked Questions

App Config.json is a modern cloud-native configuration management platform that enables development teams to define, version, deploy, and sync application settings across every environment — in real time, with zero downtime.

Instead of baking configurations into your codebase or managing scattered config files, App Config.json provides a centralized dashboard and SDK that keeps all your settings organized, encrypted, and instantly accessible to every running instance of your application.

Environment variables are static — changing them requires restarting your application. App Config.json goes further by providing:

• Real-time updates — push config changes without restarting
• Centralized dashboard — view and edit all settings from one place
• Version history & rollback — every change is tracked and reversible
• Multi-environment management — dev, staging, prod from a single interface
• Audit logging — know who changed what and when
• Encrypted secrets — sensitive data stored with AES-256 encryption

Think of it as environment variables, but dynamic, observable, and manageable at scale.

App Config.json provides official SDKs for the following languages:

• JavaScript / TypeScript (Node.js & Browser)
• Python
• Go
• Java / Kotlin
• Rust
• C# / .NET
• Ruby
• PHP

Additionally, our REST API works with any language that can make HTTP requests. Each SDK is open-source and available on GitHub.

Yes! Our Starter plan is completely free and includes:

• Up to 3 environments
• 1,000 config requests per day
• Basic versioning
• Community support

It's perfect for side projects, open-source work, and evaluating the platform before upgrading.

Install the SDK for your language using your package manager. For example:

// npm
npm install @appconfig/sdk

// pip
pip install app-config-json

// go
go get github.com/appconfig/sdk-go

Then initialize it with your project API key:

import { AppConfig } from '@appconfig/sdk';

const config = new AppConfig({
  apiKey: 'your-api-key',
  environment: 'production'
});

For detailed setup instructions, visit our Getting Started Guide.

Most developers have their first configuration live in under 5 minutes. The typical flow is:

• Sign up and create a project
• Install the SDK for your language
• Define your config schema in the dashboard
• Add the SDK to your app with your API key

We also provide migration tools to import existing config files and environment variables automatically.

Absolutely. We offer migration tools and guides for popular platforms including:

• AWS AppConfig & Parameter Store
• HashiCorp Consul
• Spring Cloud Config
• Vault / DynamoDB-based solutions
• Plain .env files and YAML configs

Our team can also assist with custom migrations. Contact us for a personalized migration plan.

Minimal changes are required. You simply add the App Config.json SDK and replace direct environment variable access with the SDK's config lookup. For example:

// Before
const api_url = process.env.API_URL;

// After
const api_url = config.get('api.url');

The SDK also supports fallback values so your app remains functional even if the config service is temporarily unavailable:

const timeout = config.get('api.timeout_ms', { fallback: 5000 });

App Config.json uses WebSocket connections to push configuration changes to all connected instances within <50ms. When you update a setting in the dashboard or via the API:

• The change is validated against your schema
• A new version is created automatically
• All instances subscribed to that environment receive the update instantly
• The SDK emits an event so your app can react to the change

config.on('change', (key, newValue) => {
  console.log(`Config updated: ${key} = ${newValue}`);
});

The SDK is designed with resilience as a first-class concern:

• Local caching — the SDK caches the latest config locally. If the service is unreachable, your app continues using the last known good configuration.
• Fallback values — you can define fallback values for critical settings at the SDK level.
• Retry logic — the SDK automatically reconnects with exponential backoff.
• Our uptime — we maintain a 99.99% SLA on Pro and Enterprise plans, backed by multi-region redundancy.

Yes. You can define a JSON Schema for your configuration to ensure type safety and validation:

{
  "type": "object",
  "properties": {
    "database": {
      "host": { "type": "string" },
      "port": { "type": "integer", "minimum": 1, "maximum": 65535 },
      "ssl": { "type": "boolean" }
    },
    "feature_flags": {
      "new_dashboard": { "type": "boolean" }
    }
  }
}

Any config update that doesn't match the schema is automatically rejected, preventing misconfigurations in production.

Yes! Feature flags are a native use case. You can define boolean config values and toggle them per environment, per user segment, or by percentage rollout.

On the Pro and Enterprise plans, you also get:

• Gradual rollouts (0% → 100%)
• Per-user or per-tenant targeting
• A/B test integration
• Scheduled flag changes

A config request is each time your application queries the App Config.json service for a configuration value via the SDK or API. Initial fetches, polling, and WebSocket subscriptions all count.

However, the SDK is optimized to minimize requests — it caches values locally and only re-fetches when changes are detected, so most applications stay well within their daily limits.

We'll never cut off your service. If you approach your limit, you'll receive email alerts at 80% and 95%. If you exceed it:

• Your existing connections continue to work (cached config is used)
• New config fetches return the last cached version
• You can upgrade your plan at any time

We believe in helping you scale, not penalizing growth.

Yes. You can downgrade or cancel at any time from your dashboard. There are no contracts or cancellation fees. If you cancel, your data is retained for 30 days so you can re-export if needed.

Downgrades take effect at the start of your next billing cycle. Upgrades are prorated and take effect immediately.

Yes! We offer special pricing programs:

• Startups — 50% off for the first 12 months for qualifying startups (Y Combinator, Techstars, 500 Startups, etc.)
• Nonprofits — Free Pro plan access for registered nonprofits
• Open Source — Free Pro plan for active open-source projects

Contact our team to apply.

We offer native integrations and CLI tools for:

• GitHub Actions
• GitLab CI/CD
• CircleCI
• Bitbucket Pipelines
• Jenkins
• AWS CodePipeline
• ArgoCD & Flux (Kubernetes)

Our CLI tool (appconfig-cli) can be added to any pipeline to validate, deploy, and sync configurations as part of your deployment process.

Yes, and it's one of our most common use cases. For Docker, simply add the SDK to your container image and pass your API key as an environment variable. For Kubernetes, we provide:

• A Kubernetes Operator that auto-injects config sidecars
• Native Helm chart integration
• Seamless replacement for Kubernetes ConfigMaps and Secrets
• Auto-sync with ArgoCD and Flux GitOps workflows

Yes. We offer out-of-the-box integrations with:

• Datadog — config change events and metrics
• Prometheus — SDK metrics for request counts, latency, and sync status
• Slack — config change notifications to channels
• PagerDuty — alerting on critical config issues
• Webhooks — custom event notifications to any endpoint

All configuration data is encrypted both in transit and at rest:

• In transit — TLS 1.3 for all API and WebSocket connections
• At rest — AES-256 encryption with per-customer encryption keys
• Secrets — marked secrets values are double-encrypted with customer-managed keys on the Enterprise plan

We are SOC 2 Type II certified and undergo annual penetration testing by independent security firms.

Yes, on Enterprise plans:

• SSO — SAML 2.0 integration with Okta, Azure AD, OneLogin, and others
• RBAC — granular role-based access control with custom roles, project-level permissions, and environment-specific access
• IP allowlists — restrict dashboard and API access to specific IP ranges
• API key rotation — rotate keys without downtime

App Config.json maintains the following certifications:

• SOC 2 Type II — annual audit
• GDPR compliant
• HIPAA — BAA available for Enterprise customers
• ISO 27001 — currently in process

We also support data residency options for EU and APAC regions on the Enterprise plan.

• Starter — 7 days
• Pro — 90 days
• Enterprise — unlimited retention, with export to S3, Snowflake, or Datadog

Audit logs capture every configuration change, including the user, timestamp, environment, previous value, and new value.

Here's a checklist to troubleshoot config sync issues:

• Check the environment — make sure you're pushing to the correct environment (dev, staging, production)
• Verify the SDK connection — enable debug logging in the SDK to confirm it's connected: config.setDebug(true)
• Check your API key — ensure the API key matches the project and environment
• Schema validation — if you have a schema defined, the change might be rejected for validation errors. Check the dashboard's activity log
• Network issues — ensure your instance can reach api.appconfig.json on port 443

A 401 error means your API key is invalid or expired. Common causes:

• The API key was deleted or rotated in the dashboard
• You're using an API key from a different project
• There's a typo or whitespace in the key (copy-paste carefully)
• The API key has environment restrictions that don't match your request

Generate a new API key from your project settings and update your application. The old key will be revoked immediately.

Yes. A few optimization strategies:

• Use the async initialization — await config.init() is parallelized and should take <100ms
• Enable local caching — the SDK stores a local snapshot. Subsequent startups will use the cache immediately
• Use a CDN-backed endpoint — for browser-based apps, our CDN delivers configs in <30ms worldwide
• Set timeout_ms appropriately — default is 5000ms, which is generous for most networks

const config = new AppConfig({
  apiKey: 'your-key',
  cache: true,
  timeout_ms: 3000
});

We love hearing from our users! You can reach us through:

• GitHub Issues — for SDK bugs: github.com/appconfig/sdk
• Discord — join our community for real-time help: discord.gg/appconfig
• Support email — support@appconfig.json (Pro & Enterprise: 4hr SLA)
• Feature requests — suggest on our public roadmap