Appwrite Terraform provider is now a HashiCorp Partner Premier provider_

When you search the Terraform Registry for a provider, the first thing you check after the name is the badge next to it. A provider without one could be maintained by the vendor, by a single contributor, or by nobody at all. That uncertainty matters when the provider is about to hold the keys to your production databases, and it is the kind of question a platform team has to answer before a new required_providers entry makes it through review.

Since April, the official Appwrite Terraform provider has let you manage Appwrite project resources as code. It shipped without a badge, because HashiCorp grants those only after reviewing the integration and the company behind it.

Today, we are announcing that Appwrite is a member of the HashiCorp Technology Partner Program, and the appwrite/appwrite provider now carries the Partner Premier badge on the Terraform Registry.

What the Partner Premier badge means

The Terraform Registry sorts providers into tiers:

• Official providers are owned and maintained by HashiCorp. Think AWS, Google Cloud, and Azure.
• Partner Premier providers meet every Partner requirement and go further. Each release ships with a software bill of materials, and the provider implements at least one of ephemeral resources, Terraform search, or Terraform actions.
• Partner providers are written, maintained, validated, and published by third-party companies against their own APIs. The company participates in the HashiCorp Technology Partner Program, and HashiCorp validates the integration before granting the badge.
• Community providers are published by individual maintainers, groups, or other members of the Terraform community, with no formal partnership or validation.

HashiCorp introduced the Partner Premier tier in April 2026 to mark providers that adopt its newer security and workflow features rather than only covering the create, read, update, and delete lifecycle. The Appwrite provider was always built and maintained by Appwrite. What changed is that HashiCorp has now verified that, reviewed the provider against the Premier criteria, and the registry says so on the provider page. The badge tells anyone evaluating the provider that the company behind the API also stands behind the Terraform integration, and that the integration keeps pace with how Terraform itself is evolving.

What changes for you

Nothing in your configuration. The provider source is still appwrite/appwrite, every resource and data source keeps its name, and no arguments changed. There is no migration, and you do not need to pin a new version to benefit.

What does change is how the provider shows up when someone else looks at it:

• Discoverability. The registry lets you filter providers by tier. Anyone who limits results to Official, Partner Premier, or Partner providers now sees the Appwrite provider, instead of only forks and experiments.
• Trust in review. Some organizations only allow Official and Partner providers. The Appwrite provider now clears that bar with room to spare, which removes one of the more tedious blockers to bringing Appwrite into infrastructure that is already managed as code.
• A verified source. HashiCorp has confirmed that the registry namespace and the GitHub repository belong to Appwrite, so what you install is what Appwrite publishes.
• A supply chain you can inspect. Every release now carries a software bill of materials, so the tooling you already use to audit dependencies can read exactly what went into the provider binary.

What the provider covers today

The provider has grown a lot since April. The 2.x line covers most of what you configure at the project level:

• TablesDB: databases, tables, columns, indexes, and rows
• Dedicated databases: PostgreSQL, MySQL, and MongoDB, with backup policies, backup storage, branches, connection poolers, and PostgreSQL extensions
• DocumentsDB and VectorsDB: databases, collections, indexes, and documents
• Storage: buckets and files
• Auth: users and teams
• Functions and Sites: the resources themselves plus variables and deployments
• Messaging: providers, topics, and subscribers
• Webhooks, backup policies, and custom domains through proxy rules

Data sources let you read resources that already exist, from looking up a database by ID to listing the compute specifications your plan allows for a dedicated database. The Terraform provider docs list every resource and data source, and the registry documentation carries the generated schema and import syntax for each one.

Getting started looks the same as it did before the badge. Declare the provider, point it at your Appwrite Cloud region or self-hosted endpoint, and start declaring resources:

terraform {
  required_providers {
    appwrite = {
      source  = "appwrite/appwrite"
      version = "~> 2.0"
    }
  }
}

provider "appwrite" {
  endpoint   = "https://<REGION>.cloud.appwrite.io/v1"
  project_id = "project-id"
  api_key    = "api-key"
}

resource "appwrite_tablesdb" "main" {
  name = "main"
}

resource "appwrite_tablesdb_table" "users" {
  database_id = appwrite_tablesdb.main.id
  name        = "users"
}

The configuration guide covers environment variables for CI, request timeouts, scoping one configuration across multiple projects, and the API key scopes each resource area needs.

The release behind the badge

The Premier criteria are not paperwork. They describe features a provider has to ship, and version 2.1.0 is where the Appwrite provider shipped them. It adds support for ephemeral resources and write-only arguments, which let Terraform handle values such as credentials at apply time without persisting them in state. Every release artifact now ships with a software bill of materials, and acceptance tests run nightly against a self-hosted Appwrite instance so regressions surface before they reach a tagged release.

None of this would have happened without Levi van Noort, who built the provider, carried it through the partner review, and maintains it. If you have hit a rough edge or want a resource the provider does not cover yet, the GitHub repository is the place to open an issue.

Getting started with the Appwrite Terraform provider

If you already manage infrastructure with Terraform, adding Appwrite to it is a short step: create a project on Appwrite Cloud, generate an API key with the scopes you need, and add the provider to your configuration. If you are evaluating Appwrite for a team that requires Partner or Official providers, that requirement is now met.

• Terraform provider overview: every resource area and data source
• Provider configuration: endpoints, environment variables, project scoping, and API keys
• Appwrite provider on the Terraform Registry: versions, generated schema, and import syntax
• Introducing Terraform support for Appwrite projects: the original launch post with end-to-end examples