---
layout: post
title: "Appwrite Terraform provider is now a HashiCorp Partner Premier provider"
description: The Appwrite Terraform provider now carries the Partner Premier badge on the HashiCorp Terraform Registry. Learn what the tier means and how to use the provider.
date: 2026-09-21
cover: /images/blog/announcing-terraform-partner-program/cover.avif
timeToRead: 5
author: aditya-oberai
category: announcements
featured: false
faqs:
  - question: "What does the Partner Premier badge on the Terraform Registry mean?"
    answer: "The Terraform Registry sorts providers into tiers. Partner providers are written, maintained, validated, and published by the company that owns the API, and HashiCorp validates the integration through its Technology Partner Program before granting the badge. Partner Premier sits above that tier. To earn it, a provider must meet every Partner requirement, ship a software bill of materials with each release, and implement at least one of ephemeral resources, Terraform search, or Terraform actions. The [Appwrite provider](https://registry.terraform.io/providers/appwrite/appwrite/latest) now shows the Partner Premier badge."
  - question: "Do I need to change my Terraform configuration now that Appwrite is a Partner Premier provider?"
    answer: "No. The provider source is still `appwrite/appwrite` and every resource, data source, and argument is unchanged. The badge is a registry designation, not a new release. Keep your `required_providers` block as it is and update the version constraint whenever you would normally pick up a new release."
  - question: "What is the difference between Official, Partner Premier, Partner, and Community providers on the Terraform Registry?"
    answer: "Official providers are owned and maintained by HashiCorp itself. Partner providers are built and maintained by third-party companies against their own APIs and validated by HashiCorp. Partner Premier providers meet every Partner requirement and also ship a software bill of materials and implement advanced Terraform features such as ephemeral resources. Community providers are published by individual maintainers or groups without a formal partnership. See HashiCorp's [provider tiers documentation](https://developer.hashicorp.com/terraform/registry/providers#provider-tiers-namespaces) for the full definitions."
  - question: "Which Appwrite resources can I manage with the Terraform provider?"
    answer: "TablesDB databases, tables, columns, indexes, and rows; dedicated PostgreSQL, MySQL, and MongoDB databases; DocumentsDB and VectorsDB; Storage buckets and files; Auth users and teams; Functions and Sites with their variables and deployments; Messaging providers, topics, and subscribers; webhooks; backup policies; and custom domains. The [Terraform provider docs](/docs/tooling/terraform) list every resource and data source."
  - question: "Does the Appwrite Terraform provider work with self-hosted Appwrite?"
    answer: "Yes. Point the `endpoint` argument at your Community Edition instance and set `self_signed = true` if it uses a certificate that is not trusted by default. The provider manages resources inside an existing Appwrite project over the API. It does not install or operate the Appwrite server. See the [configuration guide](/docs/tooling/terraform/provider) for both Cloud and self-hosted setups."
  - question: "Where do I report a bug or request a resource for the Appwrite Terraform provider?"
    answer: "Open an issue on the [appwrite/terraform-provider-appwrite](https://github.com/appwrite/terraform-provider-appwrite) repository on GitHub. The provider is open source, so pull requests are welcome too. Generated reference docs for every resource, including import syntax, live on the [Terraform Registry](https://registry.terraform.io/providers/appwrite/appwrite/latest/docs)."
---

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.

![The Appwrite provider page on the Terraform Registry showing the Partner Premier badge next to the provider name](/images/blog/announcing-terraform-partner-program/registry-partner-premier.avif)

# What the Partner Premier badge means

The [Terraform Registry](https://developer.hashicorp.com/terraform/registry/providers#provider-tiers-namespaces) 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](https://www.hashicorp.com/en/blog/announcing-the-new-partner-premier-tier-for-the-terraform-registry) 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](https://github.com/appwrite/terraform-provider-appwrite) 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](/docs/tooling/terraform) list every resource and data source, and the [registry documentation](https://registry.terraform.io/providers/appwrite/appwrite/latest/docs) 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:

```hcl
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](/docs/tooling/terraform/provider) 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](https://github.com/appwrite/terraform-provider-appwrite/releases/tag/v2.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](/blog/author/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](https://github.com/appwrite/terraform-provider-appwrite) 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](https://cloud.appwrite.io), 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](/docs/tooling/terraform): every resource area and data source
- [Provider configuration](/docs/tooling/terraform/provider): endpoints, environment variables, project scoping, and API keys
- [Appwrite provider on the Terraform Registry](https://registry.terraform.io/providers/appwrite/appwrite/latest): versions, generated schema, and import syntax
- [Introducing Terraform support for Appwrite projects](/blog/post/introducing-terraform-provider-for-appwrite): the original launch post with end-to-end examples