nself vs Appwrite

Appwrite and nself are both open-source and self-hostable. The core difference: Appwrite abstracts the database behind a REST API with its own document model. nself gives you direct PostgreSQL access with Hasura GraphQL. Both run on your server. The choice comes down to whether you want database abstraction or full SQL power.

Feature matrix

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

Where Appwrite is better

Simpler initial setup. Appwrite ships as a single Docker Compose file with a one-line install command. Configuration is minimal. nself has more services to configure (Postgres, Hasura, Auth, Nginx, optional Redis/MinIO/Search), though the CLI automates most of it. Source: [Appwrite installation](https://appwrite.io/docs/advanced/self-hosting).

Broader SDK support. Appwrite provides official SDKs for 10+ platforms (Web, Flutter, iOS, Android, React Native, Node, Python, Ruby, Kotlin, Swift, Dart) with consistent APIs. nself uses standard GraphQL clients, which work everywhere but require more setup than a purpose-built SDK. Source: [Appwrite SDKs](https://appwrite.io/docs/sdks).

Polished web console. Appwrite's console is a full-featured web UI for managing users, databases, storage, and functions. You can manage your backend from a browser. nself's admin is a local Docker companion at localhost:3021. Source: [Appwrite console](https://cloud.appwrite.io).

Simpler permission model. Appwrite's document-level permissions are straightforward: set read/write access per document using user IDs, team IDs, or roles. Hasura's role-based permission system is more powerful but has a steeper learning curve. Source: [Appwrite permissions](https://appwrite.io/docs/advanced/platform/permissions).

Where nself is better

Direct PostgreSQL access. nself runs standard PostgreSQL. You write real SQL migrations, use extensions (pgvector, PostGIS, pg_trgm), run CTEs and window functions, and connect with any Postgres client. Appwrite abstracts the database (MariaDB) behind a REST API. You cannot write SQL queries or use database-specific features. Source: [Appwrite databases](https://appwrite.io/docs/products/databases).

GraphQL with real-time subscriptions. nself provides a full Hasura GraphQL API with type-safe queries, mutations, and WebSocket subscriptions. Appwrite offers REST APIs and a basic Realtime feature via WebSocket events, but no GraphQL. Source: [nself GraphQL](https://docs.nself.org/reference/graphql), [Appwrite REST](https://appwrite.io/docs/apis/rest).

Plugin ecosystem. nself has 87 plugins covering AI assistants, media processing, chat with video calls, billing/Stripe, monitoring (Prometheus/Grafana), email (16+ providers), and full-text search (MeiliSearch). Appwrite has a functions ecosystem but no comparable plugin marketplace. Source: [nself plugins](https://docs.nself.org/plugins).

Built-in multi-tenancy and white-label. nself supports multiple tenants from one stack using table prefixes and Hasura role isolation, plus custom domains and branding. Appwrite uses teams and project isolation but has no built-in white-label support. Source: [nself multi-tenancy](https://docs.nself.org/guides/multi-tenancy).

Side-by-side pricing

*Prices from public pricing pages, verified April 2026.*

| Scale | nself | Appwrite |

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

| **Startup (10K MAU)** | $5/mo (VPS) + $0 CLI | $5/mo (VPS) + $0 self-hosted |

| **Growth (100K MAU)** | $10-20/mo (larger VPS) | $10-20/mo (larger VPS) |

| **Scale (1M MAU)** | $50-100/mo (dedicated) | $50-100/mo (dedicated) |

Both are self-hosted, so VPS costs are identical. The difference is in capabilities, not price. nself's pro plugins add $0.99/mo per bundle (or $49/yr for everything). Appwrite Cloud pricing starts at $15/mo for their Starter plan.

Choose nself if...

1. You need direct PostgreSQL access with SQL, extensions, and migrations

2. Your app uses GraphQL or needs real-time subscriptions

3. You want a plugin ecosystem for AI, media, chat, billing, or monitoring

4. You need built-in multi-tenancy with white-label and custom domains

5. You prefer a 10-service monitoring stack (Prometheus, Grafana, Loki) over basic metrics

Choose Appwrite if...

1. You prefer a simpler REST API with official SDKs for 10+ platforms

2. You want a polished web console for managing your backend

3. You do not need SQL access and are comfortable with document-style data modeling

4. You want the simplest possible Docker setup with minimal configuration

5. Document-level permissions are sufficient (no need for column-level or aggregation rules)

Migration guide

Appwrite to nself requires converting Appwrite's document model to relational tables.

### Step 1: Export Appwrite data

# Use the Appwrite CLI to list and export collections
appwrite databases listCollections \
  --databaseId YOUR_DB_ID \
  --project YOUR_PROJECT_ID

# Export documents from each collection
appwrite databases listDocuments \
  --databaseId YOUR_DB_ID \
  --collectionId YOUR_COLLECTION_ID \
  --project YOUR_PROJECT_ID \
  > collection_posts.json

### Step 2: Convert collections to SQL tables

Map Appwrite collections to PostgreSQL tables. Attributes become columns. Relationships between collections become foreign keys.

# Use the conversion script
node scripts/migrations/appwrite-to-nself/convert-collections.mjs \
  ./collection_posts.json \
  ./collection_comments.json \
  --output ./sql/

Example conversion:

-- Appwrite collection "posts" becomes:
CREATE TABLE posts (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  user_id UUID NOT NULL REFERENCES auth.users(id),
  title TEXT NOT NULL,
  content TEXT,
  status TEXT DEFAULT 'draft',
  created_at TIMESTAMPTZ DEFAULT now(),
  updated_at TIMESTAMPTZ DEFAULT now()
);

CREATE INDEX idx_posts_user_id ON posts(user_id);
CREATE INDEX idx_posts_created_at ON posts(created_at DESC);

### Step 3: Export Appwrite auth users

# List all users via Appwrite CLI
appwrite users list --project YOUR_PROJECT_ID > appwrite_users.json

# Convert to nself auth format
node scripts/migrations/appwrite-to-nself/convert-auth-users.mjs \
  appwrite_users.json \
  nself_users.json

### Step 4: Install nself and import

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

# Create schema
nself db migrate up

# Import converted data
for f in ./sql/*.sql; do
  nself db psql -f "$f"
done

# Import auth users
nself auth import nself_users.json

### Step 5: Transfer storage files

# Download files from Appwrite storage
appwrite storage listFiles --bucketId YOUR_BUCKET_ID --project YOUR_PROJECT_ID
# Download each file (or use the bulk export endpoint)

# Upload to nself MinIO
nself storage upload ./exported_files/ /default/

### Step 6: Set up Hasura relationships

# Open Hasura console to track tables and define relationships
nself hasura console

# In the console:
# 1. Track all imported tables
# 2. Define foreign key relationships (posts -> users, comments -> posts)
# 3. Set up role-based permissions

### Step 7: Update client code

Replace Appwrite SDK calls with GraphQL:

// Before (Appwrite SDK)
const posts = await databases.listDocuments(
  DATABASE_ID,
  'posts',
  [Query.equal('userId', [userId]), Query.orderDesc('$createdAt'), Query.limit(20)]
)

// After (nself / Hasura GraphQL)
const { data } = await client.query({
  query: gql`
    query GetPosts($userId: uuid!) {
      posts(
        where: { user_id: { _eq: $userId } }
        order_by: { created_at: desc }
        limit: 20
      ) {
        id
        title
        content
        created_at
      }
    }
  `,
  variables: { userId },
})
const posts = data.posts

FAQ

**Both are self-hosted and open source. Why choose nself?**

If you want direct PostgreSQL access, GraphQL subscriptions, a large plugin ecosystem (87 plugins), and built-in multi-tenancy with white-label. Choose Appwrite if you prefer a simpler REST API, broader SDK support, and a polished web console.

**Can I use Appwrite's SDKs with nself?**

No. Appwrite SDKs are built for Appwrite's proprietary REST API. With nself, use any GraphQL client (Apollo, urql, graphql-request) or generate a typed client from your Hasura schema.

**Does nself support Appwrite-style teams?**

nself implements multi-tenancy through Hasura roles and table prefixes. It is more flexible than Appwrite's teams (supports column-level permissions, row-level filtering, aggregation rules) but requires more configuration.

**Which has better file storage?**

Both support file uploads with access control. nself uses MinIO (S3-compatible), so you can use any S3 client library. Appwrite uses its own storage adapter. For most use cases, both work equally well.

**Can I use both PostgreSQL features and Appwrite's simplicity?**

Not with Appwrite. Appwrite abstracts the database and does not expose SQL. nself gives you full Postgres with the convenience of auto-generated GraphQL. The trade-off is more initial setup for more long-term power.

**What about Appwrite's Functions vs nself's plugins?**

Appwrite Functions let you run custom code in multiple runtimes. nself plugins are pre-built features (AI, media, chat, billing) that install with one command. You can also write custom Functions or Custom Services in nself for app-specific logic.

**How long does migration take?**

Plan 1-3 days for a medium-complexity app. The main work is converting Appwrite's document model to relational tables and updating client code from REST to GraphQL.

**Does nself have a cloud-hosted option like Appwrite Cloud?**

nself offers nCloud (cloud.nself.org) for managed hosting. You can also use any VPS provider. Appwrite Cloud starts at $15/mo for their Starter plan.

**Which is better for a new project starting from scratch?**

If you are comfortable with SQL and GraphQL, nself gives you more power from day one. If you want to ship a prototype fast with minimal backend configuration, Appwrite's simpler setup and SDK support can get you there faster.

**Can I migrate incrementally?**

Yes. Build new features on nself while keeping existing ones on Appwrite. Migrate collections one at a time as you convert each to a Postgres table.

Ready to try nself?

Both are open-source and self-hosted. nself adds SQL power, GraphQL, and 87 plugins. The CLI is MIT-licensed and free. Membership starts at $0.99/mo for pro plugins.

[Install nself](https://install.nself.org) | [Run the migration script on a test project](/vs/appwrite#migration-guide)