Azure HorizonDB or Azure Database for PostgreSQL Flexible Server: Choosing Azure’s PostgreSQL After Ignite 2026

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

Azure HorizonDB at GA: stateless writer and up to 15 reader nodes over zone-resilient WAL, shared data and Blob storage, and the capabilities not available at GA
One copy of the data, shared by every node. Compute nodes write only the log.

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.

CapabilityStatus at GAWhat to do instead
Cross-region reader nodesNot availableDisaster recovery is geo-redundant backup and restore to the paired region.
Read poolsNot availableOne read-write pool per cluster, with its readers.
Connection pooling (PgBouncer)Not availableRun a pooler in your own compute, or rely on application pools.
VNet injectionNot availablePrivate Link (private endpoints) is supported.
In-place major version upgradeNot availablePlan a major upgrade as a migration to a new cluster.
Long-term backup retentionNot availableRetention is 1 to 35 days; keep long-term archives elsewhere.
Customer-managed keys with geo-redundant backupNot togetherChoose one at creation; neither can be changed later.
Custom maintenance windowNot availableSystem-managed window only, with no deferral or notifications.
Index tuningNot availableTune 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.

⚠️
REGION AVAILABILITY

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

Azure HorizonDB compared with Azure Database for PostgreSQL flexible server on read scale, European regions, disaster recovery, network isolation, pooling and upgrades, and maintenance
HorizonDB wins on read scale and storage design; flexible server still wins on the operational features enterprises check first.

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:#0F2B46

The 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.

Azure portal Review + create page for a HorizonDB Dev/Test cluster: PostgreSQL 17, Sweden Central, 2 vCores, one node, high availability disabled
The Dev/Test preset: a single 2-vCore node without high availability. Public access is on, but no address can connect until a firewall rule allows it.

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.

Azure portal overview of the test HorizonDB cluster: status Ready, 2 vCores, 16 GiB RAM, PostgreSQL 17, with identifiers blurred
The cluster once Ready: separate read-write and read-only endpoints (blurred here), 2 vCores and PostgreSQL 17.

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:

Error from CREATE EXTENSION vector on HorizonDB: extension vector is not allow-listed for azure_pg_admin users
Every extension other than the preinstalled ones must be allow-listed first.

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:

Bash9 lines
# 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
Azure CLI output: azure.extensions set to vector,pg_diskann in a parameter group, applied to the pool immediately, pool Ready and InSync
The parameter group applied: azure.extensions is dynamic, the pool stays Ready and reports InSync.

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.

⚠️
THE DOCUMENTATION LAGS THE SERVICE

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:

Text5 lines
$ 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.71

At 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:

Filtered vector search results on HorizonDB: iterative scans off, strict_order, relaxed_order and pg_diskann, with rows returned, recall and latency
First of three runs on HorizonDB (PostgreSQL 17.11, pgvector 0.8.7, pg_diskann 0.7.6). The plan shows DiskANN filtering inside the search.
ModeRows returned (of 10)Recall@10, ef_search 40 / 100 / 400
HNSW, iterative scans off0.8 to 7.40.09 / 0.18–0.20 / 0.70–0.71
HNSW, strict_order100.77–0.79 / 0.83–0.84 / 0.93–0.95
HNSW, relaxed_order100.92–0.95 / 0.94–0.96 / 0.96–0.98
pg_diskann, default settings101.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.

Python160 lines
"""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.

Python121 lines
"""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 counts

Run against a PostgreSQL 16 database with pgvector, a table without a primary key and a geo-replica in its design, it reports:

Text9 lines
$ 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 2

There 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.

💡
POOLING

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.

⚖️
RETENTION AND KEYS

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.

Region8 vCores per node-hourPer vCore-hourStorage per GiB-monthExtra backup per GiB-month
East US$1.47about $0.18$0.25$0.10
Central US$1.76about $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:

ConfigurationComputeStorageExtra backupMonth
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.

📝
HOW THIS WAS CHECKED

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.

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


Discover more from C4: Container, Code, Cloud & Context

Subscribe to get the latest posts sent to your email.

Written by

Nithin Mohan TK

Hello Namaste! 👋🏻 I'm an accomplished Enterprise Solution Architect & Engineering Leader with 20+ years of progressive experience architecting, building, and scaling transformative enterprise solutions. ⚜️ Solution Architect / AI & Cloud 📌 Galway, Ireland

Leave a comment

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.