On this page
Microsoft made Azure HorizonDB generally available at Ignite on 17 November 2026, a year after it was first shown in preview. It is a managed, PostgreSQL-compatible database with compute separated from storage, built-in vector search and in-database AI functions, and Microsoft positions it for mission-critical and AI workloads. It joins Azure Database for PostgreSQL flexible server rather than replacing it, so every team starting a new PostgreSQL workload on Azure, or planning to move one, now has a real choice to make.
This article sets out how HorizonDB is built, what is and is not available at GA, how it compares with flexible server on the questions that usually decide a database platform, and what changes for vector search. It comes with a small tool that checks an existing PostgreSQL database against what HorizonDB offers, and a measurement of the filtered vector search problem that HorizonDB’s DiskANN filtering is meant to solve.
Architecture

HorizonDB rests on two ideas Microsoft describes in its documentation: compute and storage are disaggregated, and the database is the log. A cluster has one writer node and up to 15 reader nodes, each with 8 GB of memory and 32 GB of local NVMe cache per vCore. Compute nodes write only the write-ahead log (WAL). The storage layer rebuilds data pages from that log, so checkpoints, WAL archiving, shipping changes to readers and backups all happen in storage rather than on the nodes.
Storage has three zone-resilient layers: a low-latency WAL service, shared data storage sharded across many storage servers, and Azure Blob storage underneath for pages and archived WAL. There is no disk size or IOPS to provision; storage grows as data grows and is billed for what is used. Backups are Blob snapshots, so they complete quickly at any size, and a restore creates a new cluster.
For high availability, a pool needs at least two nodes, spread across availability zones. Failover promotes a reader to writer, and because the WAL is already durable in shared storage there is no log to rewind. Applications connect to two endpoints: a read-write endpoint that follows the writer through failover, and a read-only endpoint that balances across readers, whose results can lag the writer slightly.
What is not available at GA
The HorizonDB overview, updated on GA day, lists the gaps plainly. Read it as a checklist before anything else, because several of these are the kind of requirement that rules a platform out on its own.
| Capability | Status at GA | What to do instead |
|---|---|---|
| Cross-region reader nodes | Not available | Disaster recovery is geo-redundant backup and restore to the paired region. |
| Read pools | Not available | One read-write pool per cluster, with its readers. |
| Connection pooling (PgBouncer) | Not available | Run a pooler in your own compute, or rely on application pools. |
| VNet injection | Not available | Private Link (private endpoints) is supported. |
| In-place major version upgrade | Not available | Plan a major upgrade as a migration to a new cluster. |
| Long-term backup retention | Not available | Retention is 1 to 35 days; keep long-term archives elsewhere. |
| Customer-managed keys with geo-redundant backup | Not together | Choose one at creation; neither can be changed later. |
| Custom maintenance window | Not available | System-managed window only, with no deferral or notifications. |
| Index tuning | Not available | Tune indexes yourself, for example with hypopg and pg_stat_statements. |
PostgreSQL 17 is the generally available engine, with PostgreSQL 18 in preview. Microsoft’s extension list for HorizonDB, last updated in July, has 56 entries, including pgvector 0.8.0, pg_diskann 0.7.1 and PostGIS 3.5.2; pg_failover_slots is listed as not supported. The service has moved on since: the test cluster below, created on 19 November 2026, offered 87 extensions, among them pgvector 0.8.7, pg_diskann 0.7.6, PostGIS 3.6.4, Apache AGE 1.8.0, pg_cron, pgaudit, pglogical, TimescaleDB 2.24.0 and pg_duckdb 1.1.0. Query pg_available_extensions on your own cluster rather than relying on either list, and add each extension to the allow list in the parameter group before CREATE EXTENSION.
At GA, the overview lists thirteen regions, and only two in Europe: Germany West Central and Sweden Central. There is no North Europe (Ireland) or West Europe (Netherlands). For a workload that must run in a specific European country, flexible server is the option today.
Comparison with flexible server

Flexible server is a single-server design with a zone-redundant standby that receives changes synchronously, and read replicas that each hold a full copy of the data. It has the operational features HorizonDB does not yet offer: cross-region read replicas, VNet integration, a built-in PgBouncer on port 6432, in-place major version upgrades with pg_upgrade, and a choice between system-managed and custom maintenance windows. It is also available in far more regions, including North Europe and West Europe.
HorizonDB’s advantages are structural. Readers share one copy of the data instead of replicating it, storage grows without provisioning, backups and checkpoints do not compete with queries for node resources, and failover does not wait for log rewinding. Microsoft has claimed throughput up to three times that of open-source PostgreSQL for transactional workloads since the preview; treat that as a reason to benchmark your own workload, not as a planning figure.
Decision framework
%%{init: {'theme': 'base', 'themeVariables': {'primaryColor': '#EAF4FD', 'primaryTextColor': '#0F2B46', 'primaryBorderColor': '#0078D4', 'lineColor': '#243A5E', 'clusterBkg': '#F8FAFC', 'clusterBorder': '#CBD5E1', 'edgeLabelBackground': '#FFFFFF', 'nodeTextColor': '#0F2B46'}}}%%
flowchart TD
A[New or migrating PostgreSQL workload] --> B[Must the data stay in a region<br/>HorizonDB does not offer?]
B -- Yes --> F[Flexible server]
B -- No --> C[Need cross-region replicas, VNet injection,<br/>long-term retention or a custom maintenance window?]
C -- Yes --> F
C -- No --> D[Read load beyond one server,<br/>or vector and AI work in the database?]
D -- No --> F
D -- Yes --> E[Can you run your own pooler<br/>and treat major upgrades as migrations?]
E -- No --> F
E -- Yes --> H[Azure HorizonDB on PostgreSQL 17]
style F fill:#F0FFF4,stroke:#1D8102,stroke-width:2px,color:#145202
style H fill:#EAF4FD,stroke:#0078D4,stroke-width:2px,color:#0F2B46The order matters. Hard constraints come first, residency, network design, disaster recovery and retention, because no amount of performance makes up for failing one of them. Only then does the case for HorizonDB rest on what it does better: read scale beyond one server, storage that grows without planning, and vector and AI work next to transactional data. A team that cannot yet run its own connection pooler, or that relies on in-place major upgrades, should wait for those gaps to close.
Test cluster
To check the documentation against the service, a throwaway cluster was created in Sweden Central on 19 November 2026 with the portal’s Dev/Test preset: one read/write node with 2 vCores and 16 GiB of RAM, high availability disabled, PostgreSQL 17 and seven days of backups. The portal estimated INR 24,411 a month for it, which matches the list price of about €0.36 an hour. The tests below ran from Azure Cloud Shell, and the whole resource group was deleted after about forty minutes.

Provisioning took about fourteen minutes, longer than the five to ten the quickstart mentions. The cluster resource reported Succeeded after six minutes while its compute pool still had no nodes, and only reached Ready eight minutes later, so deployment scripts should wait for the cluster’s state to be Ready rather than for the first provisioning result. The preview Azure CLI extension (az extension add --name horizondb) can manage clusters, pools, firewall rules and parameter groups, but its cluster create command has no administrator or authentication options, so the first cluster came from the portal; ARM templates and the REST API are the alternatives. The connection endpoints appear on the portal’s Overview page, and firewall rules belong to the pool.

The first CREATE EXTENSION vector failed. Nothing is allow-listed on a new cluster, and the error text still names flexible server’s product, Azure Database for PostgreSQL:

The fix is a parameter group that sets azure.extensions, attached to the compute pool. Because the parameter is dynamic, applying it immediately took about two minutes and needed no restart:
# Allow-list extensions: azure.extensions is a dynamic parameter
az horizondb parameter-group create -g rg-horizondb-test -n pg-vector \
-l swedencentral --version 17 \
--parameters "[{name:azure.extensions,value:'vector,pg_diskann'}]"
# Attach the parameter group to the cluster's compute pool and apply it now
az horizondb cluster pool update -g rg-horizondb-test --cluster-name hdb-test \
-n defaultpool --param-group-id "$(az horizondb parameter-group show \
-g rg-horizondb-test -n pg-vector --query id -o tsv)" --param-group-apply Immediate
The server reported PostgreSQL 17.11 and, on 2 vCores, a max_connections of 128. That limit matters at GA, because there is no built-in PgBouncer in front of it.
On GA week, Microsoft’s extension page listed pgvector 0.8.0 and 56 extensions; the cluster offered pgvector 0.8.7 and 87. Version differences change behaviour, and a migration checklist built from the docs flagged the service’s own extensions as problems (see migration readiness below). Read pg_available_extensions on a cluster in your target region before you plan.
Vector search and filtering
HorizonDB offers two vector index families: pgvector (0.8.7 on the test cluster) with HNSW and IVFFlat, and Microsoft’s pg_diskann with what Microsoft calls advanced filtering, which pushes query predicates into the vector search itself. The filtering matters more than it sounds. An approximate index finds a fixed number of nearest candidates first and applies the WHERE clause afterwards, so a selective filter, such as one tenant, one patient or one product category, can leave a query with far fewer results than it asked for. Earlier posts cover how HNSW, IVF and product quantization narrow a search and building HNSW indexes in parallel with pgvector.
The sample first measures this locally on PostgreSQL 16.2 with pgvector 0.6.2: 20,000 random 64-dimensional vectors spread over 50 tenants, an HNSW index, and 20 queries asking for the 10 nearest neighbours within one tenant, compared with an exact search:
$ python vector_filter.py "$TEST_URI"
PostgreSQL 16.2, pgvector 0.6.2; 20,000 rows, 50 tenants (2% per tenant), k = 10
ef_search= 40: rows returned mean 0.8, min 0; recall@10 0.08
ef_search= 100: rows returned mean 1.9, min 0; recall@10 0.20
ef_search= 400: rows returned mean 7.3, min 1; recall@10 0.71At the default hnsw.ef_search of 40, a query returned fewer than one row on average when it asked for ten, and some returned none. Raising ef_search to 400 recovered most rows but not all, at a higher cost per query. Repeated runs gave the same picture within a tenth of a row, because the index build is randomised. pgvector 0.8.0 added iterative index scans (hnsw.iterative_scan) that keep scanning until enough rows pass the filter, and pg_diskann’s filtering addresses the same problem inside the index. The test cluster shows how well each works.
Measured on HorizonDB
On the test cluster, the same script runs each ef_search value with iterative scans off, in strict_order and in relaxed_order, then replaces the HNSW index with a pg_diskann index on the same rows:

| Mode | Rows returned (of 10) | Recall@10, ef_search 40 / 100 / 400 |
|---|---|---|
| HNSW, iterative scans off | 0.8 to 7.4 | 0.09 / 0.18–0.20 / 0.70–0.71 |
| HNSW, strict_order | 10 | 0.77–0.79 / 0.83–0.84 / 0.93–0.95 |
| HNSW, relaxed_order | 10 | 0.92–0.95 / 0.94–0.96 / 0.96–0.98 |
| pg_diskann, default settings | 10 | 1.00 (not tuned by ef_search) |
Ranges cover three runs. Iterative scans solve the starvation problem: every query returned ten rows. strict_order keeps results in exact distance order and gave lower recall at the default ef_search; relaxed_order may return rows slightly out of order, so sort them again if order matters, and it reached 0.92 or better at every setting. pg_diskann chose a filtered scan (DiskANNFilteredScan, “Filter() -> Vector” in the plan) and found the exact ten nearest rows in every run. Each query’s median was 25 to 34 ms, but a bare select 1 from Cloud Shell in West Europe took 24 ms, so the server’s own share was in the low single-digit milliseconds for every mode. This is one small, random dataset with one selective filter; real embeddings, larger tables and different filters will move these numbers, which is why the script is worth running on your data.
"""Measures how a selective filter interacts with an HNSW vector index.
An HNSW scan finds `hnsw.ef_search` nearest candidates first and applies the
WHERE clause afterwards. When the filter keeps only a small share of rows, a
query asking for 10 neighbours can return fewer than 10. pgvector 0.8.0
added iterative index scans (HorizonDB offered 0.8.7 in November 2026), and HorizonDB's
pg_diskann pushes filters into the vector search; this script measures the
problem itself, on whatever pgvector version the server has. On pgvector
0.8.0 or later it also measures iterative scans (`hnsw.iterative_scan`
strict_order and relaxed_order), and if the pg_diskann extension can be
created it measures a DiskANN index on the same data.
Usage: python vector_filter.py "postgresql://..." (creates and drops table vf_docs)
"""
from __future__ import annotations
import statistics
import sys
import time
from dataclasses import dataclass
import psycopg
DIM = 64
@dataclass
class Result:
ef_search: int
mean_rows: float
min_rows: int
mean_recall: float
mode: str = "off"
mean_ms: float = 0.0
def setup(conn: psycopg.Connection, rows: int = 20_000, tenants: int = 50, seed: float = 0.42) -> None:
with conn.cursor() as cur:
cur.execute("CREATE EXTENSION IF NOT EXISTS vector")
cur.execute("DROP TABLE IF EXISTS vf_docs")
cur.execute(f"CREATE TABLE vf_docs (id int PRIMARY KEY, tenant_id int NOT NULL, embedding vector({DIM}) NOT NULL)")
cur.execute("SELECT setseed(%s)", (seed,))
cur.execute(
f"""INSERT INTO vf_docs
SELECT i, i %% %s, v.a::vector
FROM generate_series(1, %s) AS i,
LATERAL (SELECT array_agg(random() - 0.5) AS a FROM generate_series(1, {DIM}) WHERE i > 0) AS v""",
(tenants, rows),
)
cur.execute("CREATE INDEX vf_docs_hnsw ON vf_docs USING hnsw (embedding vector_cosine_ops)")
cur.execute("CREATE INDEX vf_docs_tenant ON vf_docs (tenant_id)")
cur.execute("ANALYZE vf_docs")
def _query_vectors(conn: psycopg.Connection, n: int) -> list[str]:
with conn.cursor() as cur:
cur.execute("SELECT setseed(0.7)")
cur.execute(f"SELECT v.a::vector::text FROM generate_series(1, %s) AS g, "
f"LATERAL (SELECT array_agg(random() - 0.5) AS a FROM generate_series(1, {DIM}) WHERE g > 0) AS v",
(n,))
return [r[0] for r in cur.fetchall()]
def _ids(cur: psycopg.Cursor, tenant: int, q: str, k: int) -> list[int]:
cur.execute("SELECT id FROM vf_docs WHERE tenant_id = %s ORDER BY embedding <=> %s::vector LIMIT %s", (tenant, q, k))
return [r[0] for r in cur.fetchall()]
def _exact(conn: psycopg.Connection, qs: list[str], tenant: int, k: int) -> list[set[int]]:
"""Exact answers: no vector index, filter first, then sort."""
with conn.cursor() as cur:
cur.execute("BEGIN")
cur.execute("SET LOCAL enable_indexscan = off")
cur.execute("SET LOCAL enable_bitmapscan = on")
exact = [set(_ids(cur, tenant, q, k)) for q in qs]
cur.execute("COMMIT")
return exact
def _measure(conn: psycopg.Connection, settings: list[str], marker: str, label: int, mode: str,
qs: list[str], exact: list[set[int]], tenant: int, k: int) -> Result:
"""`marker` is text the query plan must contain, proving the intended index is used."""
with conn.cursor() as cur:
cur.execute("BEGIN")
for setting in settings:
cur.execute(setting)
cur.execute("SET LOCAL enable_seqscan = off")
cur.execute("SET LOCAL enable_bitmapscan = off")
plan = "\n".join(r[0] for r in cur.execute(
"EXPLAIN SELECT id FROM vf_docs WHERE tenant_id = 7 ORDER BY embedding <=> %s::vector LIMIT 10", (qs[0],)))
assert marker in plan, plan
got, times = [], []
for q in qs:
t0 = time.perf_counter()
got.append(_ids(cur, tenant, q, k))
times.append((time.perf_counter() - t0) * 1000)
cur.execute("COMMIT")
counts = [len(g) for g in got]
recall = [len(set(g) & e) / k for g, e in zip(got, exact)]
return Result(label, statistics.mean(counts), min(counts), statistics.mean(recall), mode, statistics.median(times))
def run(conn: psycopg.Connection, ef_values=(40, 100, 400), k: int = 10, queries: int = 20, tenant: int = 7,
modes=("off",)) -> list[Result]:
qs = _query_vectors(conn, queries)
exact = _exact(conn, qs, tenant, k)
results = []
for mode in modes:
for ef in ef_values:
settings = [f"SET LOCAL hnsw.ef_search = {int(ef)}"]
if mode != "off":
settings.append(f"SET LOCAL hnsw.iterative_scan = {mode}")
results.append(_measure(conn, settings, "vf_docs_hnsw", ef, mode, qs, exact, tenant, k))
return results
def run_diskann(conn: psycopg.Connection, k: int = 10, queries: int = 20, tenant: int = 7) -> Result | None:
"""Builds a DiskANN index if pg_diskann is available, measures it, and drops it again."""
try:
conn.execute("CREATE EXTENSION IF NOT EXISTS pg_diskann CASCADE")
except psycopg.Error as e:
print(f"pg_diskann not measured: {e.diag.message_primary or e}")
return None
conn.execute("DROP INDEX vf_docs_hnsw")
conn.execute("CREATE INDEX vf_docs_diskann ON vf_docs USING diskann (embedding vector_cosine_ops)")
conn.execute("ANALYZE vf_docs")
qs = _query_vectors(conn, queries)
exact = _exact(conn, qs, tenant, k)
plan = "\n".join(r[0] for r in conn.execute(
"EXPLAIN SELECT id FROM vf_docs WHERE tenant_id = 7 ORDER BY embedding <=> %s::vector LIMIT 10", (qs[0],)))
print("pg_diskann plan:\n " + plan.replace("\n", "\n "))
# pg_diskann reports a custom scan node (DiskANNFilteredScan when it filters inside the search).
return _measure(conn, [], "DiskANN", 0, "diskann", qs, exact, tenant, k)
def _version(v: str) -> tuple[int, ...]:
return tuple(int(x) for x in v.split(".")[:3] if x.isdigit())
def main(conninfo: str) -> None:
with psycopg.connect(conninfo, autocommit=True) as conn:
setup(conn)
server = conn.execute("SELECT current_setting('server_version')").fetchone()[0]
version = conn.execute("SELECT extversion FROM pg_extension WHERE extname = 'vector'").fetchone()[0]
print(f"PostgreSQL {server}, pgvector {version}; 20,000 rows, 50 tenants (2% per tenant), k = 10")
modes = ("off", "strict_order", "relaxed_order") if _version(version) >= (0, 8, 0) else ("off",)
for r in run(conn, modes=modes):
prefix = "" if len(modes) == 1 else f"iterative_scan={r.mode:<13} "
print(f"{prefix}ef_search={r.ef_search:>4}: rows returned mean {r.mean_rows:5.1f}, min {r.min_rows:2d}; "
f"recall@10 {r.mean_recall:.2f}" + (f"; median {r.mean_ms:.1f} ms" if len(modes) > 1 else ""))
if len(modes) > 1:
d = run_diskann(conn)
if d:
print(f"pg_diskann (default settings) : rows returned mean {d.mean_rows:5.1f}, "
f"min {d.min_rows:2d}; recall@10 {d.mean_recall:.2f}; median {d.mean_ms:.1f} ms")
conn.execute("DROP TABLE vf_docs")
if __name__ == "__main__":
main(sys.argv[1])Migration readiness
Moving an existing database comes down to a handful of checks: the PostgreSQL major version, the extensions in use and their versions, logical replication slots, tables that logical replication cannot handle, and how many connections the application opens. The sample’s readiness tool reads these from the source catalogs with read-only queries, takes the things SQL cannot see as flags, and reports blockers, actions and information. It exits with code 2 when there is a blocker, so it can gate a migration pipeline.
"""Turns facts about a source PostgreSQL database into findings for a move to HorizonDB.
Pure functions only: collecting the facts is in collect.py, so the rules can be
tested without a database.
"""
from __future__ import annotations
from dataclasses import dataclass, field
from enum import Enum
from .catalog import (
BUILTIN_EXTENSIONS,
HORIZONDB_EXTENSIONS,
HORIZONDB_MAJOR_VERSIONS,
HORIZONDB_UNSUPPORTED_EXTENSIONS,
NOT_AVAILABLE_AT_GA,
)
class Severity(str, Enum):
BLOCKER = "blocker" # must change before the move
ACTION = "action" # move is possible, but plan for this
INFO = "info"
@dataclass(frozen=True)
class Finding:
severity: Severity
code: str
message: str
@dataclass
class SourceFacts:
server_version_num: int # e.g. 160002
extensions: dict[str, str] # name -> installed version
logical_slots: int = 0
tables_without_pk: list[str] = field(default_factory=list)
database_bytes: int = 0
max_connections: int = 100
peak_connections: int = 0 # highest observed, from monitoring or pg_stat_activity
uses_geo_replica: bool = False # from your inventory, not detectable in SQL
needs_vnet_injection: bool = False
needs_cmk_and_geo_backup: bool = False
backup_retention_days: int = 7
@property
def major(self) -> int:
return self.server_version_num // 10000
def _version_tuple(v: str) -> tuple[int, ...]:
parts = []
for p in v.split("."):
digits = "".join(ch for ch in p if ch.isdigit())
parts.append(int(digits) if digits else 0)
return tuple(parts)
def assess(f: SourceFacts) -> list[Finding]:
out: list[Finding] = []
status = HORIZONDB_MAJOR_VERSIONS.get(f.major)
if status is None:
supported = ", ".join(f"{m} ({s})" for m, s in sorted(HORIZONDB_MAJOR_VERSIONS.items()))
out.append(Finding(Severity.BLOCKER, "major_version",
f"PostgreSQL {f.major} is not offered; HorizonDB offers {supported}. "
"Test the application on 17 first, then migrate with dump/restore or logical replication."))
elif status == "preview":
out.append(Finding(Severity.ACTION, "major_version",
f"PostgreSQL {f.major} is in preview on HorizonDB; use 17 for production."))
for name, installed in sorted(f.extensions.items()):
if name in BUILTIN_EXTENSIONS:
continue
if name in HORIZONDB_UNSUPPORTED_EXTENSIONS or name not in HORIZONDB_EXTENSIONS:
out.append(Finding(Severity.BLOCKER, f"extension:{name}",
f"Extension {name} {installed} is not available on HorizonDB."))
continue
offered = HORIZONDB_EXTENSIONS[name]
if offered and _version_tuple(installed) > _version_tuple(offered):
out.append(Finding(Severity.ACTION, f"extension:{name}",
f"{name} {installed} is newer than HorizonDB's {offered}; check that the "
"features you use exist in the older version."))
elif offered and _version_tuple(installed) < _version_tuple(offered):
out.append(Finding(Severity.INFO, f"extension:{name}",
f"{name} {installed} will be {offered} on HorizonDB; review its release notes."))
out.append(Finding(Severity.INFO, f"allowlist:{name}",
f"Add {name} to azure.extensions in the parameter group before CREATE EXTENSION."))
if f.logical_slots:
out.append(Finding(Severity.ACTION, "logical_slots",
f"{f.logical_slots} logical replication slot(s): recreate them on HorizonDB and "
"repoint consumers; pg_failover_slots is not available."))
if f.tables_without_pk:
sample = ", ".join(f.tables_without_pk[:5])
more = f" and {len(f.tables_without_pk) - 5} more" if len(f.tables_without_pk) > 5 else ""
out.append(Finding(Severity.ACTION, "no_primary_key",
f"{len(f.tables_without_pk)} table(s) without a primary key ({sample}{more}): "
"UPDATE and DELETE cannot be replicated logically without one, so a low-downtime "
"migration needs a key or REPLICA IDENTITY FULL."))
if f.peak_connections > 0.5 * f.max_connections:
out.append(Finding(Severity.ACTION, "connection_pooling",
f"Peak {f.peak_connections} of {f.max_connections} connections. "
+ NOT_AVAILABLE_AT_GA["connection_pooling"]))
if f.uses_geo_replica:
out.append(Finding(Severity.BLOCKER, "cross_region_readers", NOT_AVAILABLE_AT_GA["cross_region_readers"]))
if f.needs_vnet_injection:
out.append(Finding(Severity.BLOCKER, "vnet_injection", NOT_AVAILABLE_AT_GA["vnet_injection"]))
if f.needs_cmk_and_geo_backup:
out.append(Finding(Severity.BLOCKER, "cmk_with_geo_backup", NOT_AVAILABLE_AT_GA["cmk_with_geo_backup"]))
if f.backup_retention_days > 35:
out.append(Finding(Severity.BLOCKER, "long_term_retention", NOT_AVAILABLE_AT_GA["long_term_retention"]))
return out
def summary(findings: list[Finding]) -> dict[str, int]:
counts = {s.value: 0 for s in Severity}
for x in findings:
counts[x.severity.value] += 1
return countsRun against a PostgreSQL 16 database with pgvector, a table without a primary key and a geo-replica in its design, it reports:
$ python -m horizondb_readiness "$SOURCE_URI" --geo-replica --peak-connections 90
[BLOCKER] major_version: PostgreSQL 16 is not offered; HorizonDB offers 17 (ga), 18 (preview). Test the application on 17 first, then migrate with dump/restore or logical replication.
[INFO ] extension:vector: vector 0.6.2 will be 0.8.7 on HorizonDB; review its release notes.
[INFO ] allowlist:vector: Add vector to azure.extensions in the parameter group before CREATE EXTENSION.
[ACTION ] no_primary_key: 1 table(s) without a primary key (public.audit_log): UPDATE and DELETE cannot be replicated logically without one, so a low-downtime migration needs a key or REPLICA IDENTITY FULL.
[ACTION ] connection_pooling: Peak 90 of 100 connections. No built-in PgBouncer: run a pooler in your own compute or rely on client-side pools.
[BLOCKER] cross_region_readers: No cross-region readers: disaster recovery is geo-redundant backup and restore.
{'blocker': 2, 'action': 2, 'info': 2}
exit code 2There is no in-place path from flexible server: a move is a dump and restore, or logical replication for a low-downtime cut-over. pglogical and wal2json are on HorizonDB’s extension list. Tables without a primary key need one, or REPLICA IDENTITY FULL, before updates and deletes can be replicated logically. Test the application on PostgreSQL 17 first if it runs on an older version, because that is a major upgrade in its own right.
Pointed at the test cluster itself, the first version of the tool raised false findings: it treated HorizonDB’s preinstalled Entra authentication extension, pgaadauth, as a blocker, and reported the cluster’s own pgvector 0.8.7 as newer than HorizonDB offers, because its catalog came from the July documentation. The catalog now comes from the live cluster’s pg_available_extensions, and service-managed extensions are ignored. Treat any such catalog as a snapshot and refresh it from a cluster in your target region.
HorizonDB has no built-in PgBouncer at GA. Applications that open many short-lived connections, such as serverless functions or large container fleets, need a pooler you run yourself, close to the application, before they move. Size it on peak connections, not average.
Operations
A few operational details differ from flexible server. Extensions are enabled through the allow list in the parameter group assigned to the compute pool. Microsoft Entra authentication and PostgreSQL authentication are both available at cluster level, and firewall rules are set per pool, with no addresses allowed by default. On the 2-vCore test cluster, max_connections was 128. Maintenance follows a system-managed window, so patching cannot be scheduled around your own release calendar; build retry logic for brief disconnections into the application rather than relying on timing. The encryption type and geo-redundant backup are chosen at creation and cannot be changed, which makes them infrastructure-as-code decisions to review before the first cluster is created.
Health and financial records often need retention for years, not days. HorizonDB backups cover 1 to 35 days and long-term retention is not available, so a regulated workload needs its own archive (for example scheduled exports to immutable storage) with the retention your records policy requires. If policy requires customer-managed keys, note that they cannot be combined with geo-redundant backup at GA, and record which risk you are accepting.
Cost
Microsoft’s pricing page, read on 19 November 2026, lists four charges. Compute is billed per vCore per hour, from 2 to 192 vCores per node, and every node in a pool has the same size, so a high-availability pair costs twice its node price. Storage is billed per GiB per month for data and logs actually used. Backup storage is free up to 100% of the cluster’s initial size and billed per GiB per month beyond that. Microsoft Foundry models enabled on the cluster are billed at Foundry’s own rates and appear on the HorizonDB invoice under “AI model management”. The page shows pay-as-you-go prices only, with no HorizonDB-specific reservation listed.
| Region | 8 vCores per node-hour | Per vCore-hour | Storage per GiB-month | Extra backup per GiB-month |
|---|---|---|---|---|
| East US | $1.47 | about $0.18 | $0.25 | $0.10 |
| Central US | $1.76 | about $0.22 | $0.28 | $0.12 |
| Sweden Central | €1.45 ($1.61) | about €0.18 | €0.233 ($0.259) | €0.107 ($0.119) |
| Germany West Central | €1.45 ($1.61) | about €0.18 | €0.297 ($0.33) | €0.107 ($0.119) |
Three example months in Sweden Central, at 730 hours a month and list price, show where the money goes:
| Configuration | Compute | Storage | Extra backup | Month |
|---|---|---|---|---|
| High-availability pair, 8 vCores per node, 500 GiB | €2,117.00 | €116.50 | €0 (within allowance) | €2,233.50 |
| Same, plus two 8-vCore readers (four nodes) | €4,234.00 | €116.50 | €0 | €4,350.50 |
| High-availability pair, 16 vCores per node, 2 TiB, 1 TiB of backup beyond the allowance | €4,219.40 | €477.18 | €109.57 | €4,806.15 |
Compute is about 95% of the first bill, so node size and node count are the decisions that matter; storage is a rounding error by comparison until data runs to terabytes. Readers add compute and nothing else, because they share the cluster’s single copy of the data. The same cluster in Germany West Central costs €32 more a month at 500 GiB, all of it storage, which is 27% dearer there. These are estimates: they exclude VAT, data transfer, Foundry model usage and the compute for the connection pooler you will need to run yourself. Price your own configuration in the Azure pricing calculator before committing.
The readiness tool and the vector measurement were tested with Python 3.12, psycopg 3.2.3 and pytest 8.3.3: 10 tests pass, 6 unit tests of the rules and 4 against PostgreSQL 16.2 with pgvector 0.6.2 started by pgserver 0.1.4. On 19 November 2026 both were also run against a real Azure HorizonDB cluster (PostgreSQL 17.11, Sweden Central, Dev/Test preset, 2 vCores) from Azure Cloud Shell, three times for the vector measurement; the screenshots are from that test, with subscription details and endpoints blurred, and the cluster was deleted afterwards. That run exposed the stale extension catalog, which was rebuilt from the live server. Not tested: high availability, reader nodes, failover, backups and restore, private networking, Entra authentication and production-sized data. Architecture, limitations and regions are from Microsoft Learn pages, and list prices from the Azure HorizonDB pricing page, all read on 19 November 2026; the example months were calculated with a script at 730 hours a month; flexible server features from its overview and major version upgrade pages; GA status from Microsoft’s Ignite announcements; the pgvector iterative-scan changes from its changelog.
Key takeaways
- Azure HorizonDB is GA on PostgreSQL 17, with a shared-storage design that scales reads to 15 nodes without copying data.
- Check the GA gaps first: no cross-region readers, no PgBouncer, no VNet injection, no long-term retention, no in-place major upgrade.
- In Europe it runs only in Germany West Central and Sweden Central at GA; flexible server covers the other regions.
- Selective filters can starve an approximate vector index. On the test cluster, pgvector 0.8.7 iterative scans returned all 10 rows and pg_diskann filtering found the exact nearest rows; measure on your own data before choosing.
- Moving from flexible server is a migration, not an upgrade: check version, extensions, primary keys and pooling before you start.
Is HorizonDB on your shortlist, or do the GA gaps rule it out for now? Tell me which one decides it for you in the comments.
The complete sample for this article is on GitHub: nithinmohantk/blog-samples-working-repo/horizondb-readiness. Clone it with git clone https://github.com/nithinmohantk/blog-samples-working-repo.git and open the horizondb-readiness folder. Its README says how to run it and what has been verified.
Glossary
- Disaggregated storage
- A design where compute nodes and storage scale and fail independently.
- Database-as-a-log
- Compute writes only the write-ahead log; storage rebuilds data pages from it.
- WAL
- Write-ahead log: PostgreSQL’s record of every change, written before the data.
- Reader node
- A read-only compute node sharing the cluster’s single copy of data.
- Read-write endpoint
- The connection address that always points at the current writer.
- Parameter group
- A set of server parameters, including the extension allow list, assigned to a compute pool.
- PgBouncer
- A lightweight PostgreSQL connection pooler.
- Logical replication
- Replicating row changes by decoding the WAL, used for low-downtime migrations.
- Replica identity
- The columns PostgreSQL uses to identify a row for logical replication of updates and deletes.
- HNSW
- Hierarchical navigable small world: a graph-based approximate nearest-neighbour index.
- DiskANN
- Microsoft’s graph-based vector index, offered on HorizonDB as pg_diskann.
- Iterative index scan
- A pgvector 0.8.0 feature that keeps scanning the index until enough rows pass the filter.
- Iterative index scan
- A pgvector setting (
hnsw.iterative_scan) that keeps reading the index until enough rows pass the WHERE clause. - Parameter group
- A named set of server parameters attached to a HorizonDB compute pool, including the extension allow list.
References & Further Reading
- → What is Azure HorizonDB?— Architecture, limitations, regions and billing
- → Extensions and modules in Azure HorizonDB— The 56-entry extension list
- → Azure HorizonDB version policy— PostgreSQL 17 and 18 (preview)
- → What’s new in databases at Microsoft Ignite 2026— GA announcement and Fabric HorizonDB
- → Azure HorizonDB pricing— Compute, storage, backup and AI model charges by region
- → Azure Database for PostgreSQL flexible server overview— HA, PgBouncer, networking, maintenance, regions
- → Major version upgrades in flexible server— In-place upgrades with pg_upgrade
- → pgvector 0.8.0 changelog— Iterative index scans and filtering improvements
- → Sample code for this article— Readiness checker and filtered vector search measurement
Discover more from C4: Container, Code, Cloud & Context
Subscribe to get the latest posts sent to your email.