Appwrite's October 2026 Update: Passkeys, MCP Events, Email Triggers, and Helm

A backend platform becomes more interesting when it can do more than answer API requests. It should authenticate users safely, run application logic, store data, and tell the rest of your system when something important happens.

Appwrite's October product update adds several pieces to that picture: passkey authentication, MCP Events, email-triggered Functions, and an official Kubernetes Helm chart. The November maintenance releases also matter: Appwrite 2.7.2 backported security fixes, and 2.7.3 followed with updated runtime images.

Appwrite passkey authentication flow

Passkey flow from Appwrite's official October update. Image credit: Appwrite.

What Appwrite provides

Appwrite is an open-source backend platform with authentication, databases, storage, Functions, messaging, hosting, realtime services, and a web console. Instead of assembling every service from scratch, a team can start with one project and use the SDKs or APIs for the pieces it needs.

That is useful for mobile apps, SaaS dashboards, internal tools, prototypes, and products where a small team needs backend capabilities without owning every infrastructure component.

The project also showed up in the November 19 GitHub daily Trending snapshot. That is a useful momentum signal, but the more meaningful reason to look now is the sequence of product and maintenance releases: the October feature update, the 2.7.2 security patch on November 12, and 2.7.3 on November 17.

Passkeys are now part of the authentication flow

Passkeys replace a password with a cryptographic credential stored on a device or password manager. The user confirms with Face ID, Touch ID, a fingerprint, or a device PIN. The private key stays on the user's device; Appwrite stores the public key.

Appwrite says passkeys are available on Appwrite Cloud and self-hosted Appwrite 2.5 or later. A passkey session also satisfies multi-factor authentication because the ceremony requires user verification.

For a web application, the official SDK flow looks like this:

npm install appwrite 
import { Client, Account } from "appwrite"; const client = new Client() .setEndpoint("https://<REGION>.cloud.appwrite.io/v1") .setProject("<PROJECT_ID>"); const account = new Account(client); // The user must already have a recent authenticated session. const challenge = await account.createPasskey({ name: "MacBook" }); const credential = await navigator.credentials.create({ publicKey: PublicKeyCredential.parseCreationOptionsFromJSON( challenge.publicKey ), }); await account.updatePasskeyVerification({ passkeyId: challenge.passkeyId, credential: credential.toJSON(), }); 

This is the registration path, not the complete sign-in UI. Your application still needs to handle browser support, cancellation, errors, and the user's existing session. The relying-party domain is important: Appwrite binds a passkey to the domain configured for the project, and that value cannot be casually changed after users have registered credentials.

MCP Events: stop polling your own backend

Appwrite MCP Events event delivery

Event delivery concept from Appwrite's MCP Events announcement. Image credit: Appwrite.

The more unusual feature is MCP Events. It lets an MCP client subscribe to server-side events instead of repeatedly asking whether something has changed.

At launch, Appwrite documents six event types:

  • users.user.created
  • functions.execution.failed
  • functions.deployment.completed
  • sites.deployment.completed
  • tablesdb.row.created
  • storage.file.created

There are two delivery models. A local agent can hold an events/stream request open and receive pushed events. A hosted agent with a public HTTPS endpoint can use events/subscribe; Appwrite verifies the endpoint and sends signed POST requests.

This enables practical workflows. An agent can investigate a failed Function execution, a deployment monitor can react to a completed build, or an operations assistant can process newly uploaded files without polling every few seconds.

There is an important maturity caveat: Appwrite describes MCP Events as a proposal, with client support still getting started. The six-event launch surface is not a universal event bus. Each active stream or subscription uses one webhook in the project; the documented Free plan allows two webhooks per project, while Pro allows unlimited webhooks.

The Appwrite MCP server configuration is intentionally small:

{ "mcpServers": { "appwrite": { "url": "https://mcp.appwrite.io/", "auth": "oauth" } } } 

The official example uses the Pi agent, but the important design is the remote MCP endpoint and OAuth flow. Check the current client compatibility before making an event subscription a critical production dependency.

Email triggers and Kubernetes self-hosting

The October update also lets an Appwrite Function run when an email arrives. Each Function gets a built-in address, and a custom domain can be connected with MX and TXT records. Appwrite parses the message and passes the content as JSON, with attachments available as files.

That can remove a separate inbound-email provider for support requests, invoice extraction, or monitoring alerts. However, email triggers are currently documented as an Appwrite Cloud feature, so do not assume they are available in every self-hosted installation.

For teams that want to operate the platform themselves, Appwrite's official Helm chart is a more substantial change. The documented chart requires Kubernetes 1.29 or later, a default StorageClass, and Helm 4 or Helm 3.18 or later. It can run PostgreSQL, Redis, ClickHouse, and object storage internally, or use external managed services.

The official install command is:

helm install appwrite oci://ghcr.io/appwrite/charts/appwrite \ --namespace appwrite --create-namespace \ -f values.yaml --wait --timeout 15m 

The values file needs your domain and ingress configuration. After installation, the project recommends running helm test appwrite -n appwrite and backing up the generated encryption key. A database backup is not enough if the key needed to decrypt it is lost.

Do not skip the maintenance releases

Appwrite 2.7.2, published November 12, was a security patch for the 2.7 line. Its notes describe fixes across authentication, abuse limits, storage, realtime, messaging, Functions, version-control integrations, and the proxy. Appwrite recommended every 2.7 installation upgrade.

Version 2.7.3 followed on November 17. It rebuilt the base image and moved the OpenRuntimes executor to a newer image to clear open vulnerability findings. The release notes say an upgrade from 2.7.2 requires no schema changes.

For self-hosted installations, back up data and follow the exact upgrade and migration steps in the release notes. Avoid treating a container image update as a substitute for checking the database migration instructions.

Appwrite versus Supabase, Firebase, and PocketBase

Choose Appwrite when you want an integrated backend with self-hosting options and a broad service surface. Its new passkeys and MCP Events are particularly interesting if authentication and event-driven agent workflows are part of the product.

Supabase is often a better fit when a PostgreSQL-first architecture and direct SQL workflows are central. Firebase fits teams already invested in Google's mobile and cloud ecosystem. PocketBase is attractive for smaller applications that benefit from a compact, single-binary backend, but it is not a like-for-like replacement for Appwrite's full service set.

Appwrite's BSD-3-Clause license makes the core project permissive to use and modify. Cloud pricing and self-hosting costs are different questions: managed plans are usage and tier dependent, while self-hosting transfers the cost into compute, storage, upgrades, backups, and on-call operations.

Sources and further reading

What would you automate first with MCP Events: failed Function investigations, deployment monitoring, or new-file processing?

Written by Shaswat Raj

GitHub · LinkedIn · YouTube: StackShade