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

⚠️
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.

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:

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

Python102 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
(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.

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

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

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


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.