nself vs AWS Amplify

AWS Amplify is Amazon's full-stack framework for building web and mobile apps on top of AWS services (Cognito, DynamoDB, S3, AppSync, Lambda). nself is a self-hosted backend CLI powered by PostgreSQL and Hasura GraphQL. These are different architectural bets: AWS vendor lock-in vs full data ownership.

Feature matrix

See the [full comparison table](/compare) for a side-by-side view across nself, Supabase, Nhost, Firebase, and Appwrite.

Where AWS Amplify is better

Global AWS infrastructure. Amplify runs on AWS edge locations in 25+ regions. If you need sub-50ms latency globally, or need to keep data in a specific AWS region for compliance, Amplify's built-in geography is a real advantage. nself runs on a single VPS (or Kubernetes cluster) of your choice. Source: [AWS regions](https://aws.amazon.com/about-aws/global-infrastructure/).

Infinite scale without re-architecture. DynamoDB, AppSync, and Lambda scale to millions of requests without manual intervention. nself on a single Postgres server has a ceiling; horizontal scaling requires explicit engineering work. Source: [AWS scalability](https://aws.amazon.com/getting-started/hands-on/build-serverless-web-app-lambda-apigateway-s3-dynamodb-cognito/).

Deep AWS integration. If your company already uses SageMaker, Kinesis, SQS, RDS, ElasticSearch, or other AWS services, Amplify connects them through IAM roles and native service clients. nself integrates with external services through plugins but has no native AWS service mesh. Source: [Amplify integrations](https://docs.amplify.aws/).

Enterprise compliance certifications. AWS holds SOC 1/2/3, ISO 27001, PCI DSS, HIPAA, FedRAMP, and more. If procurement requires these certifications out of the box, AWS provides them without you doing anything. Source: [AWS compliance](https://aws.amazon.com/compliance/).

Where nself is better

Predictable costs. AWS Amplify bills per request, per data transfer, per Lambda invocation, per Cognito MAU (above 50K), and per AppSync operation. A high-traffic app can accumulate surprising bills. nself on a $20/mo VPS has a fixed monthly cost regardless of request volume. Source: [Amplify pricing](https://aws.amazon.com/amplify/pricing/), [nself pricing](https://nself.org/pricing).

SQL and PostgreSQL. AppSync uses DynamoDB (NoSQL) by default. Complex relational queries, JOINs, aggregations, and analytical queries require DynamoDB workarounds or adding Aurora. nself gives you full PostgreSQL with JSONB, pgvector, ltree, and direct SQL access. Source: [nself Postgres](https://docs.nself.org/guides/postgres).

No vendor lock-in. Amplify apps are tightly coupled to AWS: Cognito for auth, DynamoDB for data, S3 for storage, AppSync for GraphQL. Migrating away from AWS requires rewriting your data layer, auth system, and storage integration. nself uses open-source components (Postgres, Hasura, nHost Auth, MinIO) you can run anywhere. Source: [nself architecture](https://docs.nself.org/architecture).

Plugin ecosystem. nself has 87 plugins for AI assistants, media processing, real-time chat, billing, and monitoring. Amplify has the full AWS service catalog, but each service adds cost and IAM complexity. Source: [nself plugins](https://docs.nself.org/plugins).

Simpler mental model. Amplify has hundreds of configuration options, IAM policies, CloudFormation stacks, and CLI commands. nself has one binary, one CLI, and a flat config file. Source: [nself CLI](https://docs.nself.org/cli).

Side-by-side pricing

*Prices based on public AWS Amplify pricing, verified April 2026.*

| Scale | nself | AWS Amplify |

|-------|-------|-------------|

| **Dev / Prototype** | $5/mo VPS | Free tier (limited) |

| **10K MAU** | $5/mo VPS | ~$10-30/mo (Cognito + AppSync + S3) |

| **100K MAU** | $10-20/mo VPS | ~$100-300/mo (Cognito $0.0055/MAU above 50K, data transfer, operations) |

| **1M MAU** | $50-100/mo dedicated | $1,000-5,000/mo+ |

nself costs are VPS hosting only. AWS costs include Cognito MAU charges, AppSync operation fees, Lambda invocations, S3 storage and transfer, and CloudFront. Your bill depends heavily on usage patterns.

Choose nself if...

1. You want predictable flat monthly costs with no per-request billing

2. You need PostgreSQL and full SQL access for relational data and analytics

3. Data sovereignty and portability matter (avoid AWS lock-in)

4. Your team is comfortable with Linux servers and CLI tools

5. You want a plugin ecosystem for AI, media, or chat without additional AWS service configuration

Choose AWS Amplify if...

1. You need global multi-region deployment with sub-50ms latency from day one

2. You are already deep in the AWS ecosystem (SageMaker, Kinesis, RDS)

3. Enterprise compliance certifications (FedRAMP, HIPAA, PCI) are required without additional effort

4. You need to scale past millions of requests without manual intervention

5. Your app is read-heavy and NoSQL fits your data model better than SQL

Migration guide

Moving from AWS Amplify to nself. Amplify is tightly coupled to AWS, so migration involves replacing Cognito, DynamoDB/AppSync, and S3.

### Step 1: Export DynamoDB data

# Install AWS CLI and configure credentials
aws dynamodb scan --table-name YOUR_TABLE_NAME > dynamo_export.json

# For large tables, use DynamoDB Export to S3 then download
aws dynamodb export-table-to-point-in-time \
  --table-arn arn:aws:dynamodb:us-east-1:ACCOUNT:table/YOUR_TABLE \
  --s3-bucket your-export-bucket \
  --s3-prefix dynamo-export/

### Step 2: Install nself

curl -fsSL https://install.nself.org | sh
nself init my-project
cd my-project
nself start

### Step 3: Create PostgreSQL schema from DynamoDB table structure

# Design your relational schema from DynamoDB's flat key-value model
# Open Hasura console to create tables
nself hasura console

### Step 4: Import DynamoDB records into Postgres

# Write a migration script to transform and INSERT DynamoDB JSON into Postgres
node scripts/migrations/dynamodb-to-postgres/convert.mjs \
  dynamo_export.json \
  | psql "$(nself db connection-string)"

### Step 5: Migrate Cognito users

# Export Cognito user pool
aws cognito-idp list-users \
  --user-pool-id YOUR_USER_POOL_ID \
  --limit 60 > cognito_users.json

# Convert to nself auth format and import
node scripts/migrations/cognito-to-nself/convert-users.mjs \
  cognito_users.json nself_users.json

nself auth import nself_users.json

### Step 6: Migrate S3 storage

# Sync S3 bucket to local, then upload to nself MinIO storage
aws s3 sync s3://YOUR-BUCKET ./s3_export/
nself storage upload ./s3_export/ /bucket-name/

FAQ

**Does nself support GraphQL like AppSync?**

Yes. nself uses Hasura, which generates a full GraphQL API from your Postgres schema. Hasura has subscriptions, computed fields, remote schema stitching, and query caching. The API differs from AppSync's VTL-based resolvers but is equally capable.

**Can nself match AWS's global distribution?**

No. nself runs on a server you choose. For global low-latency reads, you can run multiple nself instances in different regions, but this requires manual setup. AWS Amplify distributes automatically.

**What about AWS Lambda vs nself Functions?**

nself has an optional Functions plugin that runs serverless-style code on your server. It is not globally distributed like Lambda, but it runs with zero cold-start latency since it is co-located with your database.

**Is migrating from DynamoDB to PostgreSQL always worth it?**

Not always. DynamoDB is excellent for certain access patterns (simple key lookups at massive scale). If your data is deeply relational, has complex reporting needs, or you are tired of DynamoDB's query limitations, PostgreSQL is a significant upgrade.

[Install nself](https://install.nself.org) | [View pricing](/pricing) | [See all comparisons](/compare)