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 has 56 entries, including pgvector 0.8.0, pg_diskann 0.7.1, PostGIS 3.5.2, pg_cron, pgaudit, pglogical, wal2json and Apache AGE for graph queries; pg_failover_slots is listed as not supported. Extensions have to be added to the allow list in the parameter group before CREATE EXTENSION works.
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.
Vector search and filtering
HorizonDB offers two vector index families: pgvector 0.8.0 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 measures this 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, the version HorizonDB ships, adds 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. Neither was tested here. Run this script against your own data and filters on HorizonDB before choosing an index.
"""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
(the version on HorizonDB) adds iterative index scans, and HorizonDB's
pg_diskann pushes filters into the vector search; this script measures the
problem itself, on whatever pgvector version the server has.
Usage: python vector_filter.py "postgresql://..." (creates and drops table vf_docs)
"""
from __future__ import annotations
import statistics
import sys
from dataclasses import dataclass
import psycopg
DIM = 64
@dataclass
class Result:
ef_search: int
mean_rows: float
min_rows: int
mean_recall: float
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 run(conn: psycopg.Connection, ef_values=(40, 100, 400), k: int = 10, queries: int = 20, tenant: int = 7) -> list[Result]:
qs = _query_vectors(conn, queries)
results = []
with conn.cursor() as cur:
# Exact answers: no vector index, filter first, then sort.
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")
for ef in ef_values:
cur.execute("BEGIN")
cur.execute(f"SET LOCAL hnsw.ef_search = {int(ef)}")
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 "vf_docs_hnsw" in plan, plan
got = [_ids(cur, tenant, q, k) for q in qs]
cur.execute("COMMIT")
counts = [len(g) for g in got]
recall = [len(set(g) & e) / k for g, e in zip(got, exact)]
results.append(Result(ef, statistics.mean(counts), min(counts), statistics.mean(recall)))
return results
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")
for r in run(conn):
print(f"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}")
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.0 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.
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. 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. The outputs printed above come from those runs. Nothing was run against Azure HorizonDB, which offers PostgreSQL 17 and pgvector 0.8.0; iterative scans and pg_diskann filtering were not tested. Architecture, limitations, regions and extensions 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 0.8.0 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; measure on your data and use pgvector 0.8.0 iterative scans or pg_diskann filtering.
- 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.
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.