Running Appwrite?

Appwrite functions or permissions blocking the app? We ship it properly.

Appwrite gives you a Firebase-shaped backend you can self-host, which is a big deal right up until a function hits general_unauthorized_scope, a document refuses to save because permissions were never set, or the runtime container times out before your handler finishes. We walk the project settings, the function code and the collection rules back to something predictable.

  • Since 2015Fixing technology
  • FreeEstimates
  • US teamReal engineers

appwrite-functions.log

still failing

What it is

Appwrite at a glance

Appwrite is an open-source backend platform offering databases, authentication, functions, storage, messaging and realtime subscriptions behind a consistent REST and GraphQL API. It positions itself as a self-hostable alternative to Firebase, Supabase and similar managed products.

Appwrite Inc. maintains the project under a BSD-style license and also runs Appwrite Cloud as a hosted service. Common deployments include mobile and web apps that want auth and a database without writing a server, startups that need to keep data on their own infrastructure, and teams that outgrew a BaaS and want to self-host instead.

Type
Open-source backend-as-a-service
First released
2019
License
BSD 3-Clause
Maintained by
Appwrite Inc.
Typically used for
Mobile and web app backends, auth, serverless functions, file storage, realtime channels

The honest version

Appwrite pros and cons

No technology is all upside. This is where Appwrite earns its place and where it tends to cause trouble.

Where Appwrite is strong

  • Self-hostable Firebase shapeIf the team wants Firebase ergonomics but needs the data on its own infrastructure, Appwrite covers most of the same surface with a Docker Compose stack.
  • Mature SDKs across platformsiOS, Android, Flutter, React Native, web and server SDKs stay in step with each other, which is unusual for backends of this size and age.
  • Functions on multiple runtimesNode, Python, Go, PHP, Ruby, Deno and others run as sandboxed containers, so teams can keep their preferred language rather than converting everything to one SDK.
  • Permissions per documentRow-level permissions on documents and files mean a single collection can serve many users without the application having to filter queries by hand.
  • Realtime, messaging and storage in one placeWebSocket subscriptions, push notifications, email and file storage sit alongside the database, which means less glue code between services.
  • Managed cloud existsAppwrite Cloud removes the hosting burden for teams that want the same API without running the stack themselves.

Where Appwrite bites

  • Permissions model surprises peopleFunctions, API keys and user-session calls follow different permission paths, and the error messages for a missing scope are terse enough to send a lot of time into the docs.
  • Self-hosting is non-trivialThe Compose stack is many containers, and production deployments need real attention to storage, backups, Redis, MariaDB and the function executor if they are going to behave under load.
  • Functions have cold startsThe runtime starts a container per execution model, which means cold invocations are noticeably slower than a long-running server would be, and burst traffic can line up behind one executor.
  • Database model is not relationalCollections and attributes look familiar but are not joins and foreign keys. Applications that want proper relational guarantees usually either denormalize heavily or sit Postgres next to it.
  • Upgrades can shift breaking defaultsPermission defaults, function syntax and attribute types have changed between majors in ways that required code changes on the client side, so skipping releases is risky.
  • Observability is basicFunction logs are per-execution and short-lived by default; tracing a flaky integration end to end usually means wiring in an external logging stack.

Sound familiar?

Common Appwrite problems we fix

The Appwrite problems that bring people to us, and what you have once each one is fixed.

general_unauthorized_scope (databases.read)

A function gets unauthorized from the database

A serverless function invoked without an API key trying to call database endpoints that require a server scope, so every read returns unauthorized even though the function is deployed and running.

Function API key wired in correctly

No permissions provided for action 'read'

Documents are invisible to logged-in users

A collection that was created without collection-level or document-level permissions, so even authenticated users cannot list or read their own records.

Collection rules and document permissions corrected

user_unauthorized

Setting document permissions throws user_unauthorized

A client-side call trying to set permissions for users other than the signed-in user, which Appwrite rejects to stop clients writing permissions on arbitrary identities.

Permissions written server-side via a function

function execution timed out after 15s

Functions time out before finishing

A function that waits on a slow third-party API or a large database query that exceeds the configured timeout, with the execution killed and the client receiving a 500.

Timeout raised or workload moved off the hot path

ENOENT: node_modules not found

Deployment builds succeed but the runtime fails

A build command that did not run inside the deployment or a package list that was committed without a lockfile, leaving the runtime without the dependencies it needs at execution time.

Build command and dependencies corrected

OAuth2 redirect failed: invalid_scope

Social login fails at the redirect

An OAuth provider configured with scopes the Appwrite project does not know how to parse, or a redirect URL that does not match what the provider has on file.

OAuth provider and redirect aligned

realtime websocket closed: 1011

Realtime subscriptions keep closing

A reverse proxy in front of Appwrite with WebSocket forwarding misconfigured, or a function that holds a subscription open past its memory budget and gets killed.

Realtime stable across the proxy chain

What we do

Appwrite help, from rescue to tidy self-hosting

Call us for one function returning the wrong scope, or hand us the full Appwrite stack and the apps on top.

Rescue
Functions that cannot read the database, realtime channels that keep dropping, or OAuth flows that redirect to nowhere. We settle the obvious failures first and investigate the rest.
Permissions and roles
Collection, document, function and bucket permissions designed against your actual users, with a test suite that proves the rules do what the policy says.
Function reliability
Runtime choice, timeout tuning, dependency management and cold-start behaviour improved so the serverless layer is not the slowest part of the app.
Self-hosting hardening
Compose or Kubernetes deployments with real backups for MariaDB and Redis, S3-backed storage, and monitoring that wakes somebody up before customers notice.
Migrations
Moving from Firebase, Supabase or a hand-built backend into Appwrite without losing auth records, stored files or document IDs.
Managed Tech
Upgrade testing against your project, backup verification, function-timeout alerting and a team to call when the executor stops accepting work.

How it works

From first message to fixed

  1. Look Free estimate

    Tell us what's going wrong. We look at it, then tell you plainly what's wrong and what it will cost.

  2. Fix

    We fix the cause, not the symptom. If something is down, getting it back up comes first.

  3. Harden

    Backups, monitoring, updates and access, so the same problem can't quietly come back.

  4. Hand back or stay on

    You get a plain-language write-up. Or we stay on for hosting, upkeep and new work.

Often found together

Running Appwrite alongside something else?

We work on the whole stack, so the problem can be wherever it actually is.

Questions

Appwrite questions

Something else? Call+1 737 727 7327

Should we self-host Appwrite or use Appwrite Cloud?

If data sovereignty, custom runtimes or fine control over the stack matter, self-host. If you just want the API, pay for Cloud and spend your time on the product instead. We will plainly tell you which side you are on once we see the requirements.

Why do our functions fail with unauthorized scope?

Functions that call the database with only a user session can read only what that user can read. For admin-shaped work the function needs an API key or dynamic API key with the right scopes, and those are set in the function settings rather than the client call.

How do we design collection permissions properly?

Decide which users can list, read, create, update and delete at the collection level, then set per-document permissions on sensitive rows at creation time. Writing permissions from the client for other users will fail, so anything cross-user has to go through a function with elevated access.

Can Appwrite replace our Firebase project?

For auth, database, functions, storage and realtime, mostly yes. Firebase-specific features like Firestore query behaviour, Remote Config and Analytics are not one-to-one, so a migration plan has to note which pieces need replacing rather than lifting.

How much does Appwrite help cost?

The estimate is free. Tell us what the stack looks like and what is going wrong, and we return a price before any changes are made.

Free estimate

Appwrite giving you trouble?

Tell us what you're running and what's going wrong. A person reads it and comes back with an estimate.

  • No charge to find out what it will take
  • If it's urgent, say so

Replies come from a person. By sending, you authorize us to email you back. No marketing.