Compare

# hotcfg vs S3 + CloudFront and AWS AppConfig

hotcfg is versioned JSON config at the edge, with no buckets, invalidations or IAM policies to run. How it compares with S3 + CloudFront and AWS AppConfig.

[Start free](https://hotcfg.run/login) [Read the quickstart](https://hotcfg.run/docs/quickstart)

## If you're here because…

- **Nothing stops a bad upload.** S3 stores whatever bytes it's given, so a typo, or a string where your app expects an integer, goes live the moment it's uploaded.
- **Half your users still get the old file,** because CloudFront kept the cached copy and the invalidation was slow or forgotten.
- **Rolling back means digging through object versions** and running another invalidation while production is broken.
- **AppConfig is a lot of setup for one JSON file:** an application, an environment, a configuration profile, a deployment strategy and IAM permissions, then a two-step session API instead of a plain GET.
- **Your readers are apps, not AWS servers.** Phones, browsers and game clients shouldn't need the AWS SDK, credentials or signed requests to read their config.

…hotcfg replaces that glue with one URL and a schema.

## Why hotcfg

### A schema refuses broken uploads before they go live

Attach a [JSON Schema](https://hotcfg.run/docs/guides/schemas) to a bin, and every publish, promote and rollback is checked against it before it's stored. A wrong type or a missing key is refused with the file, the line and the rule it broke:

terminal

```
$ hotcfg push flags.json --bin mobile-flags --env staging
error: flags.json does not match the schema of bin mobile-flags (1 error)

  flags.json:3  /limits/max_upload_mb
    rule:    /properties/limits/properties/max_upload_mb/type
    message: must be an integer, not a string
```

AppConfig can also check a JSON Schema, or run a Lambda function, when a deployment starts. hotcfg runs the check on every push, promote and rollback, and in the dashboard's editor as you type.

### The edge cache is purged for you

Serving JSON from S3 through CloudFront means a bucket policy, CORS headers, `Cache-Control` metadata, and an invalidation after every upload. Public bins in hotcfg are served from Cloudflare's edge with none of that set up: every publish, promote and rollback purges the cached copy, and if hotcfg's servers are ever unreachable, the edge keeps serving the last copy for up to 7 days.

### A plain HTTPS GET

Reading a public bin is one unauthenticated request, with `ETag` and `304 Not Modified`. No AWS SDK, no signed requests, no session token to carry between calls:

config.js

```
const config = await (await fetch("https://api.hotcfg.run/v1/acme/mobile-flags")).json();
```

AppConfig is built for EC2, ECS and Lambda: clients start a configuration session, then poll for the latest configuration with a token that changes on every call, or run the AppConfig Agent beside the app. A mobile app or a browser would need AWS credentials to do that. The [recommended fetching code](https://hotcfg.run/docs/guides/fetching) for hotcfg adds a 2-second timeout and a fallback to the last good copy, in one short file for each common language.

### Checked in CI, promoted with a diff

Keep the config file in your repository, and the [hotcfg GitHub Action](https://hotcfg.run/docs/guides/ci) checks every pull request against the bin's schema. On merge, push to staging; when it looks right, promote that exact version to production after reading the diff:

.github/workflows/config.yml

```
- uses: hotcfg/action@v1
  with:
    command: validate
    file: config/flags.json
    bin: acme/mobile-flags
    api-key: ${{ secrets.HOTCFG_API_KEY }}
```

On Pro, give CI a [key](https://hotcfg.run/docs/reference/keys) that can only write one bin's staging environment, with no IAM policy or OIDC trust to write.

### Types from the schema

S3 and AppConfig hand your app bytes; keeping its structs in step with the file is up to you. [`hotcfg types`](https://hotcfg.run/docs/cli/types) turns the bin's schema into the types your app decodes config into, in TypeScript, Swift, Kotlin, Java, Python, PHP, Ruby, Go, GDScript or C#:

terminal

```
hotcfg types --lang swift --bin mobile-flags -o Config.swift
```

In CI, `--check` fails the build when the committed file is out of date.

### Notifications and an audit log, built in

With S3, telling your team that `config.json` changed, and who changed it, means wiring S3 event notifications to EventBridge, Lambda or SNS. On Pro, a bin posts every publish, promote, rollback and unpublish to Slack, Discord, Microsoft Teams, Google Chat, Mattermost or Telegram, with who did it and a link to the diff, or sends a signed JSON event to your own endpoint. See [Webhooks](https://hotcfg.run/docs/guides/webhooks).

## Why pay when S3 costs pennies?

A few kilobytes of JSON in S3 cost almost nothing to store, and AppConfig charges $0.0000002 per configuration request plus $0.0008 per configuration received. The cost of rolling your own is engineering time: validation scripts, cache headers and invalidations, notification plumbing and a rollback runbook, all kept working. hotcfg is free for 3 public bins, and Pro is a flat $19 a month per organization, with unlimited reads and unlimited seats.

## At a glance

|  | hotcfg | S3 + CloudFront | AWS AppConfig |
| --- | --- | --- | --- |
| Validation | A JSON Schema checked on every publish, promote and rollback, and in CI | None built in | JSON Schema or Lambda validators, checked when a deployment starts |
| Environments | Development, staging and production in every bin, with promote and a diff | Separate prefixes or buckets you set up | An environment resource for each, per application |
| How apps read config | A plain HTTPS GET with `ETag` and `304`, from any HTTP client | A public GET through CloudFront, or signed S3 requests | The AWS SDK's session API, or the AppConfig Agent |
| After a change | The edge copy is purged automatically | A CloudFront invalidation, or wait for the cache to expire | Clients pick it up on their next poll |
| Gradual rollout | To a share of apps chosen by `?bucket=`, raised, completed or aborted by hand | None | Deployment strategies that roll out over a set time, with bake time |
| Rollback | One click or `hotcfg rollback`, to any numbered version | Restore an earlier object version, then invalidate | Stop the deployment, or deploy an earlier version; automatic on a CloudWatch alarm |
| Types in your app | Generated from the schema with `hotcfg types`, in 10 languages | None | None |
| Access control | Keys limited to bins and environments (Pro), and team roles | IAM, bucket policies and origin access control | IAM policies |
| Change notifications | Webhooks to Slack, Discord, Teams, Google Chat, Mattermost, Telegram or your endpoint (Pro) | S3 event notifications to EventBridge, SNS or Lambda | Extensions that notify EventBridge, SNS or SQS on a deployment |
| Price | Free for 3 bins; Pro $19 a month per organization, unlimited reads | S3 storage and requests, CloudFront requests and transfer, invalidations past 1,000 paths a month | $0.0000002 per request and $0.0008 per configuration received |

## What hotcfg doesn't do

- **Automatic rollouts and rollback on an alarm.** AppConfig can roll a deployment out over a set time and undo it when a CloudWatch alarm fires. A hotcfg [rollout](https://hotcfg.run/docs/guides/rollouts) moves when a person moves it, and rollbacks are made by a person: one click, one CLI command or one API call.
- **Custom validation code.** hotcfg checks config with JSON Schema only; it doesn't run your own code against it.
- **Private networking.** hotcfg is read over the public internet. It can't be reached only from inside a VPC.

## Moving from S3 or AppConfig

Download the current JSON file, create a bin with a schema that matches its shape, and upload it with `hotcfg push`. Point the app at the bin's URL with the [fetching code](https://hotcfg.run/docs/guides/fetching) for your language, and remove the bucket or the AppConfig resources once nothing reads them.

Facts about Amazon S3, CloudFront and AWS AppConfig are from [AWS's documentation](https://docs.aws.amazon.com/appconfig/) as of November 2026. Something out of date? [Tell us](https://hotcfg.run/contact).

Try it with your own config.

Free for 3 public configs (bins), each with development, staging and production. No card needed. Three short steps from sign-in to an app reading its config, in the dashboard or the CLI.

[Start free](https://hotcfg.run/login) [Read the quickstart](https://hotcfg.run/docs/quickstart)
