diff --git a/apps/studio/components/interfaces/Database/Replication/ReplicationDiagram/Edges.tsx b/apps/studio/components/interfaces/Database/Replication/ReplicationDiagram/Edges.tsx
index 7d05a6b9e60..7bfab5a8b1d 100644
--- a/apps/studio/components/interfaces/Database/Replication/ReplicationDiagram/Edges.tsx
+++ b/apps/studio/components/interfaces/Database/Replication/ReplicationDiagram/Edges.tsx
@@ -1,11 +1,14 @@
 import { BaseEdge, EdgeLabelRenderer, getSmoothStepPath, type EdgeProps } from '@xyflow/react'
-import { useParams } from 'common'
-import { ArrowRight, Loader2, Square, X, type LucideIcon } from 'lucide-react'
+import { useParams, useReducedMotion } from 'common'
 import { useMemo } from 'react'
-import { cn } from 'ui'
 
 import { getStatusName } from '../Pipeline.utils'
 import { STATUS_REFRESH_FREQUENCY_MS } from '../Replication.constants'
+import {
+  EdgeVisualChip,
+  getEdgeVisual,
+  type ReplicationState,
+} from '@/components/ui/ReactFlow/EdgeVisual'
 import { useReplicationPipelineStatusQuery } from '@/data/replication/pipeline-status-query'
 import { useReplicationPipelinesQuery } from '@/data/replication/pipelines-query'
 import {
@@ -19,67 +22,6 @@ type EdgeData = {
   shiftEdgeEnd: boolean
 }
 
-interface ReplicationState {
-  isComingUp: boolean
-  isReplicating: boolean
-  isFailed: boolean
-}
-
-interface EdgeVisual {
-  Icon: LucideIcon
-  // CSS color shared by the icon and the connecting line so they always match.
-  color: string
-  opacity: number
-  dashArray: string
-  shouldAnimate: boolean
-  shouldSpin?: boolean
-  isFilled?: boolean
-  strokeWidth?: number
-}
-
-// Picks the icon + line appearance for a replication state. Both the icon and the line are derived
-// here from the same state so they always stay in sync. We deliberately don't surface lag: the line
-// just communicates whether data is moving, stopped, starting, or broken.
-const getEdgeVisual = ({ isComingUp, isReplicating, isFailed }: ReplicationState): EdgeVisual => {
-  if (isFailed) {
-    return {
-      Icon: X,
-      color: 'hsl(var(--destructive-default))',
-      opacity: 1,
-      dashArray: '5 5',
-      shouldAnimate: false,
-      strokeWidth: 4,
-    }
-  }
-  if (isComingUp) {
-    return {
-      Icon: Loader2,
-      color: 'var(--foreground-light)',
-      opacity: 1,
-      dashArray: '5',
-      shouldAnimate: true,
-      shouldSpin: true,
-    }
-  }
-  if (isReplicating) {
-    return {
-      Icon: ArrowRight,
-      color: 'hsl(var(--brand-default))',
-      opacity: 1,
-      dashArray: '5',
-      shouldAnimate: true,
-    }
-  }
-  return {
-    Icon: Square,
-    color: 'var(--foreground-lighter)',
-    opacity: 0.5,
-    dashArray: '5 5',
-    shouldAnimate: false,
-    isFilled: true,
-  }
-}
-
 export const SmoothstepEdge = ({
   sourceX,
   sourceY,
@@ -92,6 +34,7 @@ export const SmoothstepEdge = ({
   data,
 }: EdgeProps) => {
   const { ref: projectRef = 'default' } = useParams()
+  const prefersReducedMotion = useReducedMotion()
   const { identifier, shiftEdgeEnd } = (data || {}) as EdgeData
 
   const { data: pipelinesData } = useReplicationPipelinesQuery({ projectRef })
@@ -126,16 +69,7 @@ export const SmoothstepEdge = ({
     targetPosition,
   })
 
-  const {
-    Icon,
-    color,
-    opacity,
-    dashArray,
-    shouldAnimate,
-    shouldSpin,
-    isFilled,
-    strokeWidth = 2,
-  } = getEdgeVisual(replicationState)
+  const visual = getEdgeVisual(replicationState)
 
   return (
     <>
@@ -144,11 +78,14 @@ export const SmoothstepEdge = ({
         markerEnd={markerEnd}
         style={{
           ...style,
-          stroke: color,
-          strokeWidth,
-          opacity,
-          strokeDasharray: dashArray,
-          animation: shouldAnimate ? 'dashdraw 0.5s linear infinite' : undefined,
+          stroke: visual.color,
+          strokeWidth: visual.strokeWidth,
+          opacity: visual.opacity,
+          strokeDasharray: visual.dashArray,
+          animation:
+            visual.shouldAnimate && !prefersReducedMotion
+              ? 'dashdraw 0.5s linear infinite'
+              : undefined,
         }}
       />
       <EdgeLabelRenderer>
@@ -160,18 +97,7 @@ export const SmoothstepEdge = ({
           }}
           className="nodrag nopan"
         >
-          <div
-            className={cn(
-              'w-6 h-6 rounded-full flex items-center justify-center border bg-surface-100'
-            )}
-            style={{ borderColor: color }}
-          >
-            <Icon
-              size={14}
-              className={cn(shouldSpin && 'animate-spin')}
-              style={{ color, fill: isFilled ? color : undefined }}
-            />
-          </div>
+          <EdgeVisualChip visual={visual} />
         </div>
       </EdgeLabelRenderer>
     </>
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/ComputeMetricsFooter.tsx b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/ComputeMetricsFooter.tsx
new file mode 100644
index 00000000000..4ca4b8d3b43
--- /dev/null
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/ComputeMetricsFooter.tsx
@@ -0,0 +1,81 @@
+import { useParams } from 'common'
+import Link from 'next/link'
+import { Tooltip, TooltipContent, TooltipTrigger } from 'ui'
+
+import { metricColor } from './InstanceNode.utils'
+import { useComputeMetrics } from '@/hooks/analytics/useComputeMetrics'
+
+/**
+ * Compute metrics row at the bottom of a primary database node card, linking
+ * to the database report. Metrics are project-scoped, which reports the
+ * primary on both standard and High Availability projects.
+ */
+export const ComputeMetricsFooter = ({ showConnections = true }: { showConnections?: boolean }) => {
+  const { ref } = useParams()
+
+  const {
+    cpu,
+    disk,
+    memory,
+    connections,
+    isLoading: isMetricsLoading,
+    isError: isMetricsError,
+  } = useComputeMetrics({
+    projectRef: ref,
+  })
+
+  const observabilityUrl = `/project/${ref}/observability/database`
+
+  return (
+    <Tooltip>
+      <TooltipTrigger asChild>
+        <Link
+          href={observabilityUrl}
+          className="border-t px-3 py-2 hover:bg-surface-200 transition flex items-center gap-x-3 text-xs"
+        >
+          {/* Stable live region: announces loading/failure, never the polled values */}
+          <span role="status" className="sr-only">
+            {isMetricsLoading && 'Loading metrics'}
+            {!isMetricsLoading && isMetricsError && 'Metrics unavailable'}
+          </span>
+          {/* h-4 matches the text-xs line height so the card doesn't shift when metrics load */}
+          {isMetricsLoading && (
+            <div
+              aria-hidden="true"
+              className="h-4 w-44 rounded-sm bg-surface-300 motion-safe:animate-pulse"
+            />
+          )}
+          {!isMetricsLoading && isMetricsError && (
+            <span aria-hidden="true" className="text-foreground-lighter">
+              Metrics unavailable
+            </span>
+          )}
+          {!isMetricsLoading && !isMetricsError && (
+            <>
+              <span>
+                CPU <span className={metricColor(cpu)}>{cpu.toFixed(0)}%</span>
+              </span>
+              <span className="text-foreground-lighter">·</span>
+              <span>
+                Disk <span className={metricColor(disk)}>{disk.toFixed(0)}%</span>
+              </span>
+              <span className="text-foreground-lighter">·</span>
+              <span>
+                RAM <span className={metricColor(memory)}>{memory.toFixed(0)}%</span>
+              </span>
+              {showConnections && connections.max > 0 && (
+                <>
+                  <span className="text-foreground-lighter">·</span>
+                  <span className="text-foreground-light">
+                    {connections.peak}/{connections.max} conns
+                  </span>
+                </>
+              )}
+            </>
+          )}
+        </Link>
+      </TooltipTrigger>
+      <TooltipContent side="bottom">Go to Database Report</TooltipContent>
+    </Tooltip>
+  )
+}
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/DiagramFlow.tsx b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/DiagramFlow.tsx
new file mode 100644
index 00000000000..4dd20536df8
--- /dev/null
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/DiagramFlow.tsx
@@ -0,0 +1,132 @@
+import {
+  Background,
+  ColorMode,
+  Edge,
+  EdgeTypes,
+  Node,
+  NodeTypes,
+  ReactFlow,
+  useNodesInitialized,
+  useReactFlow,
+} from '@xyflow/react'
+import { useTheme } from 'next-themes'
+import { useEffect, useEffectEvent, useState } from 'react'
+
+import '@xyflow/react/dist/style.css'
+
+import { cn } from 'ui'
+
+import { getDagreGraphLayout } from './InstanceConfiguration.utils'
+import { timeout } from '@/lib/helpers'
+
+interface DiagramFlowProps {
+  nodes: Node[]
+  edges: Edge[]
+  nodeTypes: NodeTypes
+  edgeTypes: EdgeTypes
+  /** Prepends background group nodes (regions, shards) after the dagre layout runs */
+  addGroupNodes: (nodes: Node[], edges: Edge[]) => { nodes: Node[]; edges: Edge[] }
+  ranksep?: number
+}
+
+/**
+ * Shared React Flow canvas for the infrastructure diagrams, laid out with a
+ * two-pass measured dagre layout: the first pass uses fallback heights while
+ * the diagram is held invisible, then `useNodesInitialized` triggers a second
+ * pass that re-runs dagre with the real measured node heights before fading
+ * the diagram in. Must be rendered inside a `ReactFlowProvider`.
+ */
+export const DiagramFlow = ({
+  nodes,
+  edges,
+  nodeTypes,
+  edgeTypes,
+  addGroupNodes,
+  ranksep,
+}: DiagramFlowProps) => {
+  const reactFlow = useReactFlow()
+  const { resolvedTheme } = useTheme()
+  const nodesInitialized = useNodesInitialized()
+  const [hasMeasuredLayout, setHasMeasuredLayout] = useState(false)
+
+  const backgroundPatternColor =
+    resolvedTheme === 'dark' ? 'rgba(255, 255, 255, 0.3)' : 'rgba(0, 0, 0, 0.4)'
+
+  const setReactFlow = useEffectEvent(async ({ isMeasuredPass }: { isMeasuredPass: boolean }) => {
+    // Merge in React Flow's measured dimensions (if any) so dagre can use real
+    // heights instead of the first-paint fallbacks.
+    const measuredNodes = nodes.map((node) => {
+      const existing = reactFlow.getNode(node.id)
+      return existing?.measured ? { ...node, measured: existing.measured } : node
+    })
+    const graph = getDagreGraphLayout(measuredNodes, edges, { ranksep })
+    const { nodes: groupedNodes } = addGroupNodes(graph.nodes, graph.edges)
+    // Re-attach known measurements to the freshly created group nodes too —
+    // handing setNodes an unmeasured node resets the store's nodesInitialized
+    // flag, which would re-trigger the measured pass below on every re-measure
+    // and loop forever (each iteration re-running fitView, so the diagram
+    // snaps back to center and can't be panned).
+    const updatedNodes = groupedNodes.map((node) => {
+      if (node.measured !== undefined) return node
+      const existing = reactFlow.getNode(node.id)
+      return existing?.measured ? { ...node, measured: existing.measured } : node
+    })
+    reactFlow.setNodes(updatedNodes)
+    reactFlow.setEdges(graph.edges)
+
+    // [Joshen] Odd fix to ensure that react flow snaps back to center when adding nodes
+    await timeout(1)
+    reactFlow.fitView({ maxZoom: 0.9, minZoom: 0.9 })
+    if (isMeasuredPass) setHasMeasuredLayout(true)
+  })
+
+  // First pass: lay out using fallback heights for any not-yet-measured nodes.
+  // The diagram is kept invisible until the measured pass below has run, so the
+  // user never sees the fallback positions.
+  useEffect(() => {
+    if (nodes.length > 0) {
+      setReactFlow({ isMeasuredPass: false })
+    }
+  }, [nodes, edges])
+
+  // Second pass: once React Flow has measured the nodes, re-run the layout so
+  // dagre uses real heights. Only `nodesInitialized` going true should trigger
+  // this — the first-pass effect above handles node changes.
+  const runMeasuredLayout = useEffectEvent(() => {
+    if (nodesInitialized && nodes.length > 0) {
+      setReactFlow({ isMeasuredPass: true })
+    }
+  })
+  useEffect(() => {
+    runMeasuredLayout()
+  }, [nodesInitialized])
+
+  return (
+    <ReactFlow
+      // FIXME: https://github.com/xyflow/xyflow/issues/4876
+      colorMode={'' as unknown as ColorMode}
+      fitView
+      fitViewOptions={{ minZoom: 0.9, maxZoom: 0.9 }}
+      // Keep the diagram invisible (but laid out, so nodes can be measured)
+      // until the measured-height layout pass has run.
+      className={cn(
+        'instance-configuration transition-opacity duration-150',
+        hasMeasuredLayout ? 'opacity-100' : 'opacity-0'
+      )}
+      zoomOnPinch={false}
+      zoomOnScroll={false}
+      nodesDraggable={false}
+      nodesConnectable={false}
+      zoomOnDoubleClick={false}
+      edgesFocusable={false}
+      edgesReconnectable={false}
+      defaultNodes={[]}
+      defaultEdges={[]}
+      nodeTypes={nodeTypes}
+      edgeTypes={edgeTypes}
+      proOptions={{ hideAttribution: true }}
+    >
+      <Background color={backgroundPatternColor} />
+    </ReactFlow>
+  )
+}
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaInstanceConfiguration.tsx b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaInstanceConfiguration.tsx
new file mode 100644
index 00000000000..0a5c0681998
--- /dev/null
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaInstanceConfiguration.tsx
@@ -0,0 +1,113 @@
+import { useQuery } from '@tanstack/react-query'
+import { useParams } from 'common'
+import { Loader2 } from 'lucide-react'
+import { useMemo } from 'react'
+
+import { DiagramFlow } from './DiagramFlow'
+import { addShardNodes, generateHaNodesAndEdges } from './HaInstanceConfiguration.utils'
+import { HaPrimaryNode, HaReplicaNode, HaShardNode, MultigatewayNode } from './HaInstanceNode'
+import { buildHaTopology, selectTopologyPoolers } from './HaTopology.utils'
+import { HA_RANKSEP } from './InstanceConfiguration.constants'
+import { AlertError } from '@/components/ui/AlertError'
+import { HighAvailabilityDisabledEmptyState } from '@/components/ui/HighAvailability/HighAvailabilityDisabledEmptyState'
+import { haClusterGatewaysQueryOptions } from '@/data/ha-admin/ha-cluster-gateways-query'
+import { haClusterPoolersQueryOptions } from '@/data/ha-admin/ha-cluster-poolers-query'
+
+const nodeTypes = {
+  HA_GATEWAY: MultigatewayNode,
+  HA_PRIMARY: HaPrimaryNode,
+  HA_REPLICA: HaReplicaNode,
+  HA_SHARD: HaShardNode,
+}
+
+// The gateway and replication edges both use React Flow's built-in smoothstep.
+const edgeTypes = {}
+
+const POOLER_STATUS_REFRESH_MS = 30_000
+
+/**
+ * Cluster topology diagram for High Availability (Multigres) projects:
+ * gateway tier → shard group → primary + read replicas, driven by the
+ * read-only multiadmin `/ha-admin` passthrough.
+ */
+export const HaInstanceConfiguration = () => {
+  const { ref: projectRef } = useParams()
+
+  // Gateways poll on the same interval as poolers so the gateway count and
+  // gateway→primary edge track cluster changes while the page stays open.
+  const {
+    data: gatewaysData,
+    error: gatewaysError,
+    isPending: isPendingGateways,
+    isError: isErrorGateways,
+  } = useQuery({
+    ...haClusterGatewaysQueryOptions({ projectRef }),
+    refetchInterval: POOLER_STATUS_REFRESH_MS,
+  })
+
+  const {
+    data: poolers,
+    error: poolersError,
+    isPending: isPendingPoolers,
+    isError: isErrorPoolers,
+  } = useQuery({
+    ...haClusterPoolersQueryOptions({ projectRef }),
+    refetchInterval: POOLER_STATUS_REFRESH_MS,
+    select: selectTopologyPoolers,
+  })
+
+  const gateways = gatewaysData?.gateways
+
+  const { nodes, edges } = useMemo(
+    () =>
+      generateHaNodesAndEdges(
+        buildHaTopology({ gateways: gateways ?? [], poolers: poolers ?? [] })
+      ),
+    [gateways, poolers]
+  )
+
+  const isPending = isPendingGateways || isPendingPoolers
+  const isError = isErrorGateways || isErrorPoolers
+  const error = gatewaysError ?? poolersError
+
+  if (isPending) {
+    return (
+      <div role="status" className="h-full w-full flex items-center justify-center">
+        <span className="sr-only">Loading cluster topology...</span>
+        <Loader2 aria-hidden="true" className="motion-safe:animate-spin text-foreground-light" />
+      </div>
+    )
+  }
+
+  if (isError) {
+    return (
+      <div className="h-full w-full flex items-center justify-center px-28">
+        <AlertError error={error} subject="Failed to retrieve cluster topology" />
+      </div>
+    )
+  }
+
+  if ((poolers ?? []).length === 0) {
+    return (
+      <div className="h-full w-full flex items-center justify-center p-6">
+        <HighAvailabilityDisabledEmptyState
+          title="Cluster topology unavailable"
+          description="Topology data for this project is not available yet. Contact support if this persists."
+        />
+      </div>
+    )
+  }
+
+  return (
+    <div className="nowheel h-full w-full relative">
+      <DiagramFlow
+        nodes={nodes}
+        edges={edges}
+        nodeTypes={nodeTypes}
+        edgeTypes={edgeTypes}
+        addGroupNodes={addShardNodes}
+        ranksep={HA_RANKSEP}
+      />
+    </div>
+  )
+}
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaInstanceConfiguration.utils.test.ts b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaInstanceConfiguration.utils.test.ts
new file mode 100644
index 00000000000..bb8dc47848d
--- /dev/null
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaInstanceConfiguration.utils.test.ts
@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest'
+
+import { generateHaNodesAndEdges } from './HaInstanceConfiguration.utils'
+import { buildHaTopology } from './HaTopology.utils'
+
+describe('generateHaNodesAndEdges', () => {
+  it('gives every pooler a unique node id even when identities are omitted', () => {
+    const topology = buildHaTopology({
+      gateways: [],
+      poolers: [
+        {
+          id: { cell: 'cell-1', name: 'p-1' },
+          shardKey: { shard: '0' },
+          routingState: { role: 'ROUTING_ROLE_PRIMARY' },
+        },
+        { shardKey: { shard: '0' }, routingState: { role: 'ROUTING_ROLE_REPLICA' } },
+        { shardKey: { shard: '0' }, routingState: { role: 'ROUTING_ROLE_REPLICA' } },
+      ],
+    })
+
+    const { nodes, edges } = generateHaNodesAndEdges(topology)
+    const poolerNodeIds = nodes
+      .filter((node) => node.type === 'HA_PRIMARY' || node.type === 'HA_REPLICA')
+      .map((node) => node.id)
+
+    expect(poolerNodeIds).toHaveLength(3)
+    expect(new Set(poolerNodeIds).size).toBe(3)
+    // Each replica still gets its own edge from the primary.
+    expect(edges).toHaveLength(2)
+    expect(new Set(edges.map((edge) => edge.id)).size).toBe(2)
+  })
+})
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaInstanceConfiguration.utils.ts b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaInstanceConfiguration.utils.ts
new file mode 100644
index 00000000000..8521ddea287
--- /dev/null
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaInstanceConfiguration.utils.ts
@@ -0,0 +1,154 @@
+import { Edge, Node } from '@xyflow/react'
+import { groupBy } from 'lodash'
+
+import { getPoolerKey, hasPoolerIdentity, HaTopology } from './HaTopology.utils'
+import {
+  NODE_CARD_WIDTH,
+  SHARD_HEADER_HEIGHT,
+  SHARD_NODE_PADDING,
+} from './InstanceConfiguration.constants'
+import { getDagreNodeHeight } from './InstanceConfiguration.utils'
+
+export type MultigatewayNodeData = {
+  numGateways: number
+}
+
+export type HaPoolerNodeData = {
+  cell?: string
+  name?: string
+  shardId: string
+  shardName: string
+  // Only set on primary nodes; hides the unused top handle when no gateway exists.
+  hasGateway?: boolean
+}
+
+export type HaShardNodeData = {
+  name: string
+}
+
+// Records without a complete identity fall back to a positional id so two of
+// them never collide on the same React Flow node id (which would drop a card).
+const getPoolerNodeId = (pooler: Parameters<typeof getPoolerKey>[0], fallbackId: string) =>
+  hasPoolerIdentity(pooler) ? `pooler-${getPoolerKey(pooler)}` : `pooler-${fallbackId}`
+
+export const generateHaNodesAndEdges = (topology: HaTopology): { nodes: Node[]; edges: Edge[] } => {
+  const position = { x: 0, y: 0 }
+  const nodes: Node[] = []
+  const edges: Edge[] = []
+
+  // The alpha runs one multigateway per cell; the diagram collapses them into a
+  // single gateway node with a count rather than rendering one card per cell.
+  const hasGateway = topology.gateways.length > 0
+  if (hasGateway) {
+    nodes.push({
+      position,
+      id: 'multigateway',
+      type: 'HA_GATEWAY',
+      data: { numGateways: topology.gateways.length } satisfies MultigatewayNodeData,
+    })
+  }
+
+  topology.shards.forEach((shard) => {
+    let primaryId: string | undefined
+
+    if (shard.primary !== undefined) {
+      primaryId = getPoolerNodeId(shard.primary, `${shard.id}-primary`)
+      nodes.push({
+        position,
+        id: primaryId,
+        type: 'HA_PRIMARY',
+        data: {
+          cell: shard.primary.id?.cell,
+          name: shard.primary.id?.name,
+          shardId: shard.id,
+          shardName: shard.name,
+          hasGateway,
+        } satisfies HaPoolerNodeData,
+      })
+
+      if (hasGateway) {
+        edges.push({
+          id: `multigateway-${primaryId}`,
+          source: 'multigateway',
+          target: primaryId,
+          type: 'smoothstep',
+          className: 'cursor-default!',
+        })
+      }
+    }
+
+    shard.replicas.forEach((replica, replicaIndex) => {
+      const replicaId = getPoolerNodeId(replica, `${shard.id}-replica-${replicaIndex}`)
+      nodes.push({
+        position,
+        id: replicaId,
+        type: 'HA_REPLICA',
+        data: {
+          cell: replica.id?.cell,
+          name: replica.id?.name,
+          shardId: shard.id,
+          shardName: shard.name,
+        } satisfies HaPoolerNodeData,
+      })
+
+      if (primaryId !== undefined) {
+        edges.push({
+          id: `${primaryId}-${replicaId}`,
+          source: primaryId,
+          target: replicaId,
+          type: 'smoothstep',
+          animated: true,
+          className: 'cursor-default!',
+        })
+      }
+    })
+  })
+
+  return { nodes, edges }
+}
+
+const getNodeWidth = (node: Node) => node.measured?.width ?? NODE_CARD_WIDTH
+
+/**
+ * Prepends a background group node per shard wrapping its primary + replicas,
+ * using the same fake-subflow trick as `addRegionNodes` (dagre has no subflow
+ * support, so the box is sized from the laid-out children's bounding box).
+ */
+export const addShardNodes = (nodes: Node[], edges: Edge[]) => {
+  const shardNodes: Node[] = []
+  const poolerNodes = nodes.filter(
+    (node) => node.type === 'HA_PRIMARY' || node.type === 'HA_REPLICA'
+  ) as Node<HaPoolerNodeData>[]
+
+  const nodesByShard = groupBy(poolerNodes, (node) => node.data.shardId)
+  Object.entries(nodesByShard).forEach(([shardId, children]) => {
+    const minX = Math.min(...children.map((node) => node.position.x))
+    const maxX = Math.max(...children.map((node) => node.position.x + getNodeWidth(node)))
+    const minY = Math.min(...children.map((node) => node.position.y))
+    const maxY = Math.max(...children.map((node) => node.position.y + getDagreNodeHeight(node)))
+
+    shardNodes.push({
+      id: `shard-${shardId}`,
+      position: {
+        x: minX - SHARD_NODE_PADDING,
+        y: minY - SHARD_HEADER_HEIGHT - SHARD_NODE_PADDING,
+      },
+      // Explicit dimensions so React Flow renders the node immediately —
+      // without them a node stays `visibility: hidden` until a measurement
+      // pass that this post-layout background node never gets.
+      width: maxX - minX + SHARD_NODE_PADDING * 2,
+      height: maxY - minY + SHARD_HEADER_HEIGHT + SHARD_NODE_PADDING * 2,
+      // The box covers most of the canvas; making it non-interactive lets
+      // React Flow drop its pointer events so drag-to-pan passes through to
+      // the pane. The header pill re-enables pointer events for its tooltip.
+      selectable: false,
+      focusable: false,
+      type: 'HA_SHARD',
+      data: {
+        name: children[0].data.shardName,
+      } satisfies HaShardNodeData,
+    })
+  })
+
+  return { nodes: [...shardNodes, ...nodes], edges }
+}
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaInstanceNode.tsx b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaInstanceNode.tsx
new file mode 100644
index 00000000000..7c439e4de59
--- /dev/null
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaInstanceNode.tsx
@@ -0,0 +1,190 @@
+import { Handle, Node, NodeProps, Position } from '@xyflow/react'
+import { Database, DatabaseBackup, HelpCircle, Layers, Loader2, Network } from 'lucide-react'
+import { Badge, cn, Tooltip, TooltipContent, TooltipTrigger } from 'ui'
+
+import { ComputeMetricsFooter } from './ComputeMetricsFooter'
+import {
+  HaPoolerNodeData,
+  HaShardNodeData,
+  MultigatewayNodeData,
+} from './HaInstanceConfiguration.utils'
+import { HA_POOLER_STATUS_LABELS, HaPoolerStatus } from './HaTopology.utils'
+import { NODE_CARD_WIDTH } from './InstanceConfiguration.constants'
+import { useHaPoolerCard } from './useHaPooler'
+import { BASE_PATH } from '@/lib/constants'
+
+const STATUS_BADGE_VARIANTS: Record<HaPoolerStatus, 'success' | 'warning' | 'default'> = {
+  healthy: 'success',
+  coming_up: 'default',
+  going_down: 'default',
+  unhealthy: 'warning',
+}
+
+const PoolerStatusBadge = ({ status }: { status: HaPoolerStatus }) => (
+  <Badge variant={STATUS_BADGE_VARIANTS[status]}>{HA_POOLER_STATUS_LABELS[status]}</Badge>
+)
+
+const PoolerCardSubtitle = ({
+  availabilityZone,
+  computeSize,
+}: {
+  availabilityZone?: string
+  computeSize?: string
+}) => (
+  <p className="flex items-center gap-x-1 text-sm text-foreground-light">
+    {availabilityZone !== undefined && <span>{availabilityZone}</span>}
+    {availabilityZone !== undefined && !!computeSize && (
+      <span className="text-foreground-lighter">·</span>
+    )}
+    {!!computeSize && <span>{computeSize}</span>}
+  </p>
+)
+
+export const MultigatewayNode = ({ data }: NodeProps<Node<MultigatewayNodeData>>) => {
+  const { numGateways } = data
+
+  return (
+    <>
+      <div className="flex flex-col rounded-sm bg-surface-100 border border-default">
+        <div className="flex items-start p-3 gap-x-4" style={{ width: NODE_CARD_WIDTH }}>
+          <div className="flex gap-x-3">
+            <div className="min-w-8 h-8 bg-blue-600 border border-blue-800 rounded-md flex items-center justify-center">
+              <Network aria-hidden="true" size={16} />
+            </div>
+            <div className="flex flex-col gap-y-0.5">
+              <p className="text-sm">Multigateway</p>
+              <p className="flex items-center gap-x-1 text-sm text-foreground-light">
+                <span>Load balancer</span>
+                {numGateways > 1 && (
+                  <>
+                    <span className="text-foreground-lighter">·</span>
+                    <span>{numGateways} instances</span>
+                  </>
+                )}
+              </p>
+            </div>
+          </div>
+        </div>
+      </div>
+      <Handle type="source" position={Position.Bottom} style={{ background: 'transparent' }} />
+    </>
+  )
+}
+
+export const HaPrimaryNode = ({ data }: NodeProps<Node<HaPoolerNodeData>>) => {
+  // [Joshen] Just FYI Handles cannot be conditionally rendered
+  const { cell, name, hasGateway } = data
+  const { status, availabilityZone, computeSize, primaryRegion } = useHaPoolerCard({ cell, name })
+
+  return (
+    <>
+      <Handle
+        type="target"
+        position={Position.Top}
+        className={!hasGateway ? 'opacity-0' : ''}
+        style={{ background: 'transparent' }}
+      />
+      <div className="flex flex-col rounded-sm bg-surface-100 border border-default">
+        <div className="flex items-start justify-between p-3" style={{ width: NODE_CARD_WIDTH }}>
+          <div className="flex gap-x-3">
+            <div className="w-8 h-8 bg-brand-500 border border-brand-600 rounded-md flex items-center justify-center">
+              <Database aria-hidden="true" size={16} />
+            </div>
+            <div className="flex flex-col gap-y-0.5">
+              <div className="flex items-center gap-x-2">
+                <p className="text-sm">Primary Database</p>
+                {/* Stable live region so polled status changes are announced */}
+                <span role="status">
+                  {status !== undefined && <PoolerStatusBadge status={status} />}
+                </span>
+              </div>
+              {primaryRegion !== undefined && (
+                <p className="text-sm text-foreground-light">{primaryRegion.name}</p>
+              )}
+              <PoolerCardSubtitle availabilityZone={availabilityZone} computeSize={computeSize} />
+            </div>
+          </div>
+          {primaryRegion !== undefined && (
+            // Decorative — the visible text next to it already names the region
+            <img
+              alt=""
+              aria-hidden="true"
+              className="w-8 rounded-xs mt-0.5"
+              src={`${BASE_PATH}/img/regions/${primaryRegion.region}.svg`}
+            />
+          )}
+        </div>
+        {/* Whether connection metrics are meaningful through the multigateway
+            is unconfirmed, so they're left off for HA projects. */}
+        <ComputeMetricsFooter showConnections={false} />
+      </div>
+      <Handle type="source" position={Position.Bottom} style={{ background: 'transparent' }} />
+    </>
+  )
+}
+
+export const HaReplicaNode = ({ data }: NodeProps<Node<HaPoolerNodeData>>) => {
+  const { cell, name } = data
+  const { status, availabilityZone, computeSize } = useHaPoolerCard({ cell, name })
+
+  return (
+    <>
+      <Handle type="target" position={Position.Top} style={{ background: 'transparent' }} />
+      <div
+        className="flex items-start rounded-sm bg-surface-100 border border-default p-3"
+        style={{ width: NODE_CARD_WIDTH }}
+      >
+        <div className="flex gap-x-3">
+          <div
+            className={cn(
+              'w-8 h-8 border rounded-md flex items-center justify-center',
+              status === 'healthy'
+                ? 'bg-brand-400 border-brand-500'
+                : 'bg-surface-100 border-foreground/20'
+            )}
+          >
+            {status === 'coming_up' ? (
+              <Loader2 aria-hidden="true" className="motion-safe:animate-spin" size={16} />
+            ) : (
+              <DatabaseBackup aria-hidden="true" size={16} />
+            )}
+          </div>
+          <div className="flex flex-col gap-y-0.5">
+            <div className="flex items-center gap-x-2">
+              <p className="text-sm">Read Replica</p>
+              {/* Stable live region so polled status changes are announced */}
+              <span role="status">
+                {status !== undefined && <PoolerStatusBadge status={status} />}
+              </span>
+            </div>
+            <PoolerCardSubtitle availabilityZone={availabilityZone} computeSize={computeSize} />
+          </div>
+        </div>
+      </div>
+    </>
+  )
+}
+
+export const HaShardNode = ({ data }: NodeProps<Node<HaShardNodeData>>) => {
+  const { name } = data
+
+  return (
+    <div className="relative h-full w-full rounded-md border border-default bg-surface-100/25">
+      <div className="pointer-events-auto absolute top-3 left-3 flex items-center gap-x-2 rounded-full border border-default bg-surface-100 pl-3 pr-2 py-1">
+        <Layers aria-hidden="true" size={14} className="text-foreground-light" />
+        <p className="text-sm">{name}</p>
+        <Tooltip>
+          {/* Renders a button so the explanation is keyboard reachable */}
+          <TooltipTrigger className="flex items-center gap-x-1 text-sm text-foreground-light">
+            Automatic failover
+            <HelpCircle aria-hidden="true" size={14} />
+          </TooltipTrigger>
+          <TooltipContent side="bottom" className="max-w-72 text-center">
+            If the primary database fails, a replica in this shard is automatically promoted to take
+            its place.
+          </TooltipContent>
+        </Tooltip>
+      </div>
+    </div>
+  )
+}
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaTopology.utils.test.ts b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaTopology.utils.test.ts
new file mode 100644
index 00000000000..6e8d77ba78d
--- /dev/null
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaTopology.utils.test.ts
@@ -0,0 +1,292 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  buildHaTopology,
+  formatCellAsAvailabilityZone,
+  getPoolerStatus,
+  isPrimaryPooler,
+  selectTopologyPoolers,
+} from './HaTopology.utils'
+import type { Multipooler } from '@/data/ha-admin/ha-cluster-poolers-query'
+
+const primaryPooler = (overrides: Partial<Multipooler> = {}): Multipooler => ({
+  id: { cell: 'eu-central-1a', name: 'pooler-1' },
+  shardKey: { database: 'postgres', shard: '0' },
+  routingState: { role: 'ROUTING_ROLE_PRIMARY' },
+  ...overrides,
+})
+
+const replicaPooler = (overrides: Partial<Multipooler> = {}): Multipooler => ({
+  id: { cell: 'eu-central-1b', name: 'pooler-2' },
+  shardKey: { database: 'postgres', shard: '0' },
+  routingState: { role: 'ROUTING_ROLE_REPLICA' },
+  ...overrides,
+})
+
+describe('isPrimaryPooler', () => {
+  it('uses routingState.role as the authoritative signal', () => {
+    expect(isPrimaryPooler(primaryPooler())).toBe(true)
+    expect(isPrimaryPooler(replicaPooler())).toBe(false)
+  })
+
+  it('prefers routingState.role over the deprecated type field', () => {
+    expect(isPrimaryPooler(replicaPooler({ type: 'PRIMARY' }))).toBe(false)
+  })
+
+  it('falls back to the deprecated type field when routingState is omitted', () => {
+    expect(isPrimaryPooler({ type: 'PRIMARY' })).toBe(true)
+    expect(isPrimaryPooler({ type: 'REPLICA' })).toBe(false)
+  })
+
+  it('treats a pooler with every field omitted as a replica', () => {
+    expect(isPrimaryPooler({})).toBe(false)
+  })
+})
+
+describe('getPoolerStatus', () => {
+  it('treats a pooler with every field omitted as healthy (proto3 zero values mean SERVING)', () => {
+    expect(getPoolerStatus({})).toBe('healthy')
+  })
+
+  it('maps lifecycle states with or without the proto enum prefix', () => {
+    expect(getPoolerStatus({ lifecycleStatus: { status: 'STARTING' } })).toBe('coming_up')
+    expect(getPoolerStatus({ lifecycleStatus: { status: 'LIFECYCLE_STARTING' } })).toBe('coming_up')
+    expect(getPoolerStatus({ lifecycleStatus: { status: 'STOPPING' } })).toBe('going_down')
+    expect(getPoolerStatus({ lifecycleStatus: { status: 'SHUTDOWN' } })).toBe('unhealthy')
+    expect(getPoolerStatus({ lifecycleStatus: { status: 'QUARANTINED' } })).toBe('unhealthy')
+  })
+
+  it('falls back to serving status when the lifecycle is active', () => {
+    const active = { lifecycleStatus: { status: 'ACTIVE' } }
+    expect(getPoolerStatus({ ...active })).toBe('healthy')
+    expect(getPoolerStatus({ ...active, servingStatus: 'DRAINING' })).toBe('going_down')
+    expect(getPoolerStatus({ ...active, servingStatus: 'DISABLED' })).toBe('unhealthy')
+    expect(getPoolerStatus({ ...active, servingStatus: 'SERVING' })).toBe('healthy')
+  })
+
+  it('prioritizes a terminal lifecycle over the serving status', () => {
+    expect(
+      getPoolerStatus({ lifecycleStatus: { status: 'QUARANTINED' }, servingStatus: 'SERVING' })
+    ).toBe('unhealthy')
+  })
+})
+
+describe('formatCellAsAvailabilityZone', () => {
+  it('returns an AZ-shaped cell as is', () => {
+    expect(formatCellAsAvailabilityZone('eu-central-1a')).toBe('eu-central-1a')
+  })
+
+  it('extracts an AZ-shaped substring from a longer cell name', () => {
+    expect(formatCellAsAvailabilityZone('cell-eu-central-1a')).toBe('eu-central-1a')
+    expect(formatCellAsAvailabilityZone('ap-southeast-2c-0')).toBe('ap-southeast-2c')
+  })
+
+  it('falls back to the raw cell name when no AZ shape is found', () => {
+    expect(formatCellAsAvailabilityZone('cell-1')).toBe('cell-1')
+  })
+
+  it('returns undefined for an omitted cell', () => {
+    expect(formatCellAsAvailabilityZone(undefined)).toBeUndefined()
+    expect(formatCellAsAvailabilityZone('')).toBeUndefined()
+  })
+})
+
+describe('selectTopologyPoolers', () => {
+  it('projects poolers down to identity, shard, and routing role', () => {
+    const projected = selectTopologyPoolers({
+      poolers: [
+        {
+          id: { cell: 'cell-1', name: 'p-1' },
+          shardKey: { database: 'postgres', tableGroup: 'default', shard: '0-inf' },
+          type: 'PRIMARY',
+          hostname: 'some-host',
+          servingStatus: 'DRAINING',
+          lifecycleStatus: { status: 'LIFECYCLE_ACTIVE' },
+          routingState: {
+            role: 'ROUTING_ROLE_PRIMARY',
+            rule: { coordinatorTerm: '2', leaderSubterm: '1' },
+          },
+        },
+      ],
+    })
+
+    // Volatile fields (lifecycle, serving status, hostname) are dropped so the
+    // projection stays deep-equal across polls when the topology is unchanged.
+    // The routing rule is kept — it decides the primary during failover.
+    expect(projected).toEqual([
+      {
+        id: { cell: 'cell-1', name: 'p-1' },
+        shardKey: { database: 'postgres', tableGroup: 'default', shard: '0-inf' },
+        routingState: {
+          role: 'ROUTING_ROLE_PRIMARY',
+          rule: { coordinatorTerm: '2', leaderSubterm: '1' },
+        },
+        type: 'PRIMARY',
+      },
+    ])
+  })
+
+  it('preserves omitted fields as undefined and handles an empty response', () => {
+    expect(selectTopologyPoolers({})).toEqual([])
+    expect(selectTopologyPoolers({ poolers: [{}] })).toEqual([
+      { id: undefined, shardKey: undefined, routingState: undefined, type: undefined },
+    ])
+  })
+})
+
+describe('buildHaTopology', () => {
+  it('groups poolers into a shard with a primary and replicas', () => {
+    const primary = primaryPooler()
+    const replicaB = replicaPooler()
+    const replicaC = replicaPooler({ id: { cell: 'eu-central-1c', name: 'pooler-3' } })
+
+    const topology = buildHaTopology({
+      gateways: [{ id: { cell: 'eu-central-1a', name: 'gateway-1' } }],
+      poolers: [replicaC, primary, replicaB],
+    })
+
+    expect(topology.gateways).toHaveLength(1)
+    expect(topology.shards).toHaveLength(1)
+    expect(topology.shards[0].name).toBe('Shard 1')
+    expect(topology.shards[0].primary).toEqual(primary)
+    // Replicas are sorted by cell/name for a stable layout.
+    expect(topology.shards[0].replicas).toEqual([replicaB, replicaC])
+  })
+
+  it('splits poolers with different shard keys into separate shards', () => {
+    const topology = buildHaTopology({
+      gateways: [],
+      poolers: [
+        primaryPooler({ shardKey: { database: 'postgres', shard: '1' } }),
+        primaryPooler({
+          id: { cell: 'eu-central-1b', name: 'pooler-9' },
+          shardKey: { database: 'postgres', shard: '0' },
+        }),
+      ],
+    })
+
+    expect(topology.shards).toHaveLength(2)
+    expect(topology.shards.map((shard) => shard.name)).toEqual(['Shard 1', 'Shard 2'])
+    expect(topology.shards[0].primary?.shardKey?.shard).toBe('0')
+    expect(topology.shards[1].primary?.shardKey?.shard).toBe('1')
+  })
+
+  it('groups poolers with omitted shard keys into a single shard', () => {
+    const topology = buildHaTopology({
+      gateways: [],
+      poolers: [primaryPooler({ shardKey: undefined }), replicaPooler({ shardKey: undefined })],
+    })
+
+    expect(topology.shards).toHaveLength(1)
+    expect(topology.shards[0].replicas).toHaveLength(1)
+  })
+
+  it('keeps extra primaries as replicas instead of dropping them (tie keeps sort order)', () => {
+    const first = primaryPooler()
+    const second = primaryPooler({ id: { cell: 'eu-central-1b', name: 'pooler-2' } })
+
+    const topology = buildHaTopology({ gateways: [], poolers: [second, first] })
+
+    expect(topology.shards[0].primary).toEqual(first)
+    expect(topology.shards[0].replicas).toEqual([second])
+  })
+
+  it('elects the primary claimant with the highest coordinator term during failover', () => {
+    // '9' vs '10' also guards against lexicographic string comparison.
+    const outgoing = primaryPooler({
+      routingState: { role: 'ROUTING_ROLE_PRIMARY', rule: { coordinatorTerm: '9' } },
+    })
+    const incoming = primaryPooler({
+      id: { cell: 'eu-central-1b', name: 'pooler-2' },
+      routingState: { role: 'ROUTING_ROLE_PRIMARY', rule: { coordinatorTerm: '10' } },
+    })
+
+    const topology = buildHaTopology({ gateways: [], poolers: [outgoing, incoming] })
+
+    expect(topology.shards[0].primary).toEqual(incoming)
+    expect(topology.shards[0].replicas).toEqual([outgoing])
+  })
+
+  it('breaks coordinator-term ties on leader subterm', () => {
+    const lower = primaryPooler({
+      routingState: {
+        role: 'ROUTING_ROLE_PRIMARY',
+        rule: { coordinatorTerm: '2', leaderSubterm: '1' },
+      },
+    })
+    const higher = primaryPooler({
+      id: { cell: 'eu-central-1b', name: 'pooler-2' },
+      routingState: {
+        role: 'ROUTING_ROLE_PRIMARY',
+        rule: { coordinatorTerm: '2', leaderSubterm: '2' },
+      },
+    })
+
+    const topology = buildHaTopology({ gateways: [], poolers: [lower, higher] })
+
+    expect(topology.shards[0].primary).toEqual(higher)
+  })
+
+  it('prefers a claimant with a routing rule over one without (omitted terms are zero)', () => {
+    const withoutRule = primaryPooler()
+    const withRule = primaryPooler({
+      id: { cell: 'eu-central-1b', name: 'pooler-2' },
+      routingState: { role: 'ROUTING_ROLE_PRIMARY', rule: { coordinatorTerm: '1' } },
+    })
+
+    const topology = buildHaTopology({ gateways: [], poolers: [withoutRule, withRule] })
+
+    expect(topology.shards[0].primary).toEqual(withRule)
+    expect(topology.shards[0].replicas).toEqual([withoutRule])
+  })
+
+  it('handles a shard with no primary', () => {
+    const topology = buildHaTopology({ gateways: [], poolers: [replicaPooler()] })
+
+    expect(topology.shards[0].primary).toBeUndefined()
+    expect(topology.shards[0].replicas).toHaveLength(1)
+  })
+
+  it('dedupes repeated records by id (the passthrough returns one copy per cell)', () => {
+    const gateway = { id: { cell: 'cell-1', name: 'gw-1' } }
+    const primary = primaryPooler({
+      id: { cell: 'cell-1', name: 'p-1' },
+      lifecycleStatus: { status: 'LIFECYCLE_ACTIVE' },
+    })
+    const replica = replicaPooler({ id: { cell: 'cell-2', name: 'p-2' } })
+
+    const topology = buildHaTopology({
+      gateways: [gateway, gateway, gateway],
+      poolers: [primary, replica, primary, replica, primary, replica],
+    })
+
+    expect(topology.gateways).toEqual([gateway])
+    expect(topology.shards).toHaveLength(1)
+    // Duplicate copies of the primary must not be demoted to replicas.
+    expect(topology.shards[0].primary).toEqual(primary)
+    expect(topology.shards[0].replicas).toEqual([replica])
+  })
+
+  it('never dedupes records with omitted identity', () => {
+    const identityless = (overrides: Partial<Multipooler> = {}): Multipooler => ({
+      shardKey: { database: 'postgres', shard: '0' },
+      routingState: { role: 'ROUTING_ROLE_REPLICA' },
+      ...overrides,
+    })
+
+    const topology = buildHaTopology({
+      gateways: [{}, {}],
+      poolers: [primaryPooler(), identityless(), identityless()],
+    })
+
+    expect(topology.gateways).toHaveLength(2)
+    expect(topology.shards[0].replicas).toHaveLength(2)
+  })
+
+  it('returns an empty topology for empty responses', () => {
+    const topology = buildHaTopology({ gateways: [], poolers: [] })
+
+    expect(topology.gateways).toEqual([])
+    expect(topology.shards).toEqual([])
+  })
+})
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaTopology.utils.ts b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaTopology.utils.ts
new file mode 100644
index 00000000000..1624caf53b2
--- /dev/null
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/HaTopology.utils.ts
@@ -0,0 +1,192 @@
+import { groupBy, partition, uniqBy } from 'lodash'
+
+import type { Multigateway } from '@/data/ha-admin/ha-cluster-gateways-query'
+import type { HaClusterPoolersData, Multipooler } from '@/data/ha-admin/ha-cluster-poolers-query'
+
+/**
+ * Pure helpers mapping the multiadmin cluster state (gateways + poolers) onto
+ * the shapes the High Availability infrastructure diagram renders. Every field
+ * on the multiadmin responses is optional because proto3 JSON omits zero
+ * values — an absent field means "the default", not "missing data".
+ */
+
+export type HaPoolerStatus = 'healthy' | 'coming_up' | 'going_down' | 'unhealthy'
+
+export interface HaShard {
+  id: string
+  name: string
+  primary?: Multipooler
+  replicas: Multipooler[]
+}
+
+export interface HaTopology {
+  gateways: Multigateway[]
+  shards: HaShard[]
+}
+
+export const getPoolerKey = (pooler: Pick<Multipooler, 'id'>) =>
+  `${pooler.id?.cell ?? 'unknown'}-${pooler.id?.name ?? 'unknown'}`
+
+export const hasPoolerIdentity = (pooler: Pick<Multipooler, 'id'>) =>
+  pooler.id?.cell !== undefined && pooler.id?.name !== undefined
+
+/**
+ * `routingState.role` is the authoritative writable signal; the deprecated
+ * `type` field is derived and only used as a fallback when the routing state is
+ * missing. The role is omitted entirely when it is ROUTING_ROLE_UNKNOWN
+ * (proto3 zero value).
+ */
+export const isPrimaryPooler = (pooler: Multipooler) => {
+  const role = pooler.routingState?.role
+  if (role !== undefined) return role === 'ROUTING_ROLE_PRIMARY'
+  return pooler.type === 'PRIMARY'
+}
+
+/**
+ * Health as reported by the pooler's topology record — not a live probe: a
+ * pooler that crashes without publishing STOPPING/SHUTDOWN can leave an
+ * ACTIVE/SERVING record behind until the topology evicts it, and "healthy"
+ * says nothing about replication progress. Live signals (WAL receiver state,
+ * replay position) exist on `GET /poolers/{cell}/{name}/status` but require a
+ * per-pooler fanout.
+ */
+export const getPoolerStatus = (pooler: Multipooler): HaPoolerStatus => {
+  // Lifecycle values may arrive with or without the proto enum prefix.
+  const lifecycle = (pooler.lifecycleStatus?.status ?? '').replace(/^LIFECYCLE_/, '')
+
+  if (lifecycle === 'QUARANTINED' || lifecycle === 'SHUTDOWN') return 'unhealthy'
+  if (lifecycle === 'STARTING') return 'coming_up'
+  if (lifecycle === 'STOPPING') return 'going_down'
+
+  // Lifecycle is ACTIVE or unknown: fall back to the serving status. An absent
+  // servingStatus means SERVING (proto3 zero value), i.e. the node is taking
+  // traffic, so the default reads as healthy.
+  if (pooler.servingStatus === 'DRAINING') return 'going_down'
+  if (pooler.servingStatus === 'DISABLED') return 'unhealthy'
+  return 'healthy'
+}
+
+// Matches the status vocabulary of the read replica surfaces (getStatusLabel).
+export const HA_POOLER_STATUS_LABELS: Record<HaPoolerStatus, string> = {
+  healthy: 'Healthy',
+  coming_up: 'Coming up',
+  going_down: 'Going down',
+  unhealthy: 'Unhealthy',
+}
+
+const AWS_AZ_REGEX = /\b[a-z]{2}(?:-[a-z]+)+-\d[a-z]\b/
+
+/**
+ * Cells map 1:1 to availability zones in the alpha, but the exact cell naming
+ * format is unconfirmed — extract an AZ-shaped substring when there is one and
+ * fall back to the raw cell name otherwise.
+ */
+export const formatCellAsAvailabilityZone = (cell: string | undefined) => {
+  if (!cell) return undefined
+  return AWS_AZ_REGEX.exec(cell)?.[0] ?? cell
+}
+
+// Routing-rule terms are proto int64s, serialized as strings in JSON and
+// omitted when zero. Failover counts stay far below Number's safe range.
+const parseTerm = (value: string | undefined) => {
+  const parsed = Number(value ?? 0)
+  return Number.isFinite(parsed) ? parsed : 0
+}
+
+// Orders two primary claimants by routing rule: (coordinator term, leader
+// subterm), greatest wins.
+const compareRoutingRules = (a: Multipooler, b: Multipooler) => {
+  const ruleA = a.routingState?.rule
+  const ruleB = b.routingState?.rule
+  return (
+    parseTerm(ruleA?.coordinatorTerm) - parseTerm(ruleB?.coordinatorTerm) ||
+    parseTerm(ruleA?.leaderSubterm) - parseTerm(ruleB?.leaderSubterm)
+  )
+}
+
+export const buildHaTopology = ({
+  gateways,
+  poolers,
+}: {
+  gateways: Multigateway[]
+  poolers: Multipooler[]
+}): HaTopology => {
+  // The /ha-admin passthrough can return the same record multiple times (one
+  // copy per cell it fans out to), so both lists must be deduped by id —
+  // duplicate poolers would otherwise produce duplicate React Flow node ids,
+  // and extra copies of the primary would render as replicas. Records without
+  // a complete identity can't be told apart, so they are never deduped (keying
+  // by the record itself keeps each one unique).
+  const uniqueGateways = uniqBy(gateways, (gateway) =>
+    hasPoolerIdentity(gateway) ? getPoolerKey(gateway) : gateway
+  )
+  const uniquePoolers = uniqBy(poolers, (pooler) =>
+    hasPoolerIdentity(pooler) ? getPoolerKey(pooler) : pooler
+  )
+
+  const sortedPoolers = [...uniquePoolers].sort((a, b) =>
+    getPoolerKey(a).localeCompare(getPoolerKey(b))
+  )
+  const poolersByShard = groupBy(
+    sortedPoolers,
+    (pooler) =>
+      `${pooler.shardKey?.database ?? ''}/${pooler.shardKey?.tableGroup ?? ''}/${pooler.shardKey?.shard ?? ''}`
+  )
+
+  const shards = Object.entries(poolersByShard)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([id, shardPoolers], index) => {
+      const [primaries, replicas] = partition(shardPoolers, isPrimaryPooler)
+      // During a failover the outgoing and incoming primary can briefly both
+      // claim ROUTING_ROLE_PRIMARY — the highest routing rule wins, matching
+      // the multigateway's election. Losing claimants render as replicas
+      // rather than being dropped; ties keep the first in sorted order so the
+      // result stays deterministic.
+      const primary = primaries.reduce<Multipooler | undefined>(
+        (best, candidate) =>
+          best === undefined || compareRoutingRules(candidate, best) > 0 ? candidate : best,
+        undefined
+      )
+      return {
+        id,
+        name: `Shard ${index + 1}`,
+        primary,
+        replicas: [...primaries.filter((pooler) => pooler !== primary), ...replicas],
+      }
+    })
+
+  return { gateways: uniqueGateways, shards }
+}
+
+/**
+ * Query `select` projecting poolers down to the fields the topology depends on
+ * (identity, shard, routing role) — live status is self-fetched by the
+ * individual nodes and edges. React Query's structural sharing then keeps the
+ * result referentially stable across polls, so refetches only re-run
+ * layout/fitView when the topology actually changes (volatile fields like
+ * lifecycle timestamps would otherwise churn the data identity on every poll).
+ */
+const projectRoutingRule = (rule: NonNullable<Multipooler['routingState']>['rule']) =>
+  rule === undefined
+    ? undefined
+    : { coordinatorTerm: rule.coordinatorTerm, leaderSubterm: rule.leaderSubterm }
+
+const projectRoutingState = (routingState: Multipooler['routingState']) =>
+  routingState === undefined
+    ? undefined
+    : { role: routingState.role, rule: projectRoutingRule(routingState.rule) }
+
+export const selectTopologyPoolers = (data: HaClusterPoolersData): Multipooler[] =>
+  (data.poolers ?? []).map((pooler) => ({
+    id: pooler.id === undefined ? undefined : { cell: pooler.id.cell, name: pooler.id.name },
+    shardKey:
+      pooler.shardKey === undefined
+        ? undefined
+        : {
+            database: pooler.shardKey.database,
+            tableGroup: pooler.shardKey.tableGroup,
+            shard: pooler.shardKey.shard,
+          },
+    routingState: projectRoutingState(pooler.routingState),
+    type: pooler.type,
+  }))
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.constants.ts b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.constants.ts
index 2d49e4739cc..7f8f2b2b6db 100644
--- a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.constants.ts
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.constants.ts
@@ -44,9 +44,22 @@ export type EdgeData = {
 export const NODE_WIDTH = 660
 export const NODE_SEP = 20
 
+// Rendered width of the node cards; dagre lays out with NODE_WIDTH / 2 so
+// cards get a little breathing room between columns.
+export const NODE_CARD_WIDTH = NODE_WIDTH / 2 - 10
+
 // The region wrapper is a static, non-measured sibling node with a fixed size.
 export const REGION_NODE_HEIGHT = 162
 
+// The shard wrapper is a static, non-measured background node sized around its
+// children, with room reserved above them for the group header pill.
+export const SHARD_NODE_PADDING = 16
+export const SHARD_HEADER_HEIGHT = 42
+
+// dagre rank separation for the High Availability layout — leaves room for the
+// shard group header between the gateway row and the primary row.
+export const HA_RANKSEP = 96
+
 // First-paint fallback heights for the dagre layout, only used before React
 // Flow has measured the real nodes. Subsequent layouts use node.measured.height.
 export const NODE_HEIGHT_FALLBACKS: Record<string, number> = {
@@ -54,6 +67,9 @@ export const NODE_HEIGHT_FALLBACKS: Record<string, number> = {
   PRIMARY: 140,
   READ_REPLICA: 140,
   REGION: REGION_NODE_HEIGHT,
+  HA_GATEWAY: 64,
+  HA_PRIMARY: 150,
+  HA_REPLICA: 90,
 }
 
 // [Joshen] Coordinates from https://github.com/tobilg/aws-edge-locations/blob/main/data/aws-edge-locations.json
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.tsx b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.tsx
index c49a7416010..7b4b4732259 100644
--- a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.tsx
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.tsx
@@ -1,24 +1,14 @@
-import {
-  Background,
-  ColorMode,
-  Edge,
-  ReactFlow,
-  ReactFlowProvider,
-  useNodesInitialized,
-  useReactFlow,
-} from '@xyflow/react'
+import { Edge, ReactFlowProvider } from '@xyflow/react'
+import { useParams } from 'common'
 import { partition } from 'lodash'
 import { Globe2, Loader2, Network } from 'lucide-react'
-import { useTheme } from 'next-themes'
-import { useEffect, useEffectEvent, useMemo, useState } from 'react'
-
-import '@xyflow/react/dist/style.css'
-
-import { useParams } from 'common'
-import { Button, cn } from 'ui'
+import { useEffect, useMemo, useState } from 'react'
+import { Button } from 'ui'
 
+import { DiagramFlow } from './DiagramFlow'
 import { SmoothstepEdge } from './Edge'
-import { addRegionNodes, generateNodes, getDagreGraphLayout } from './InstanceConfiguration.utils'
+import { HaInstanceConfiguration } from './HaInstanceConfiguration'
+import { addRegionNodes, generateNodes } from './InstanceConfiguration.utils'
 import { LoadBalancerNode, PrimaryNode, RegionNode, ReplicaNode } from './InstanceNode'
 import MapView from './MapView'
 import { REPLICA_STATUS } from '@/components/interfaces/Settings/Infrastructure/ReadReplicas/ReadReplicas.constants'
@@ -29,13 +19,22 @@ import {
   ReplicaInitializationStatus,
   useReadReplicasStatusesQuery,
 } from '@/data/read-replicas/replicas-status-query'
+import { useHighAvailability } from '@/hooks/misc/useHighAvailability'
 import { useIsFeatureEnabled } from '@/hooks/misc/useIsFeatureEnabled'
 import { useIsAwsCloudProvider, useSelectedProjectQuery } from '@/hooks/misc/useSelectedProject'
-import { timeout } from '@/lib/helpers'
+
+const nodeTypes = {
+  PRIMARY: PrimaryNode,
+  READ_REPLICA: ReplicaNode,
+  REGION: RegionNode,
+  LOAD_BALANCER: LoadBalancerNode,
+}
+
+const edgeTypes = {
+  smoothstep: SmoothstepEdge,
+}
 
 const InstanceConfigurationUI = () => {
-  const reactFlow = useReactFlow()
-  const { resolvedTheme } = useTheme()
   const { ref: projectRef } = useParams()
   const { isPending: isLoadingProject } = useSelectedProjectQuery()
 
@@ -109,9 +108,6 @@ const InstanceConfigurationUI = () => {
     replicasStatuses,
   ])
 
-  const backgroundPatternColor =
-    resolvedTheme === 'dark' ? 'rgba(255, 255, 255, 0.3)' : 'rgba(0, 0, 0, 0.4)'
-
   const nodes = useMemo(
     () =>
       isSuccessReplicas && isSuccessLoadBalancers && primary !== undefined
@@ -135,7 +131,8 @@ const InstanceConfigurationUI = () => {
                     source: 'load-balancer',
                     target: primary.identifier,
                     type: 'smoothstep',
-                    animated: true,
+                    // Static: no data flows between the load balancer and the
+                    // database — the line only indicates a relation.
                     className: 'cursor-default!',
                   },
                 ]
@@ -160,76 +157,21 @@ const InstanceConfigurationUI = () => {
     [isSuccessLoadBalancers, isSuccessReplicas, loadBalancers, primary?.identifier, replicas]
   )
 
-  const nodeTypes = useMemo(
-    () => ({
-      PRIMARY: PrimaryNode,
-      READ_REPLICA: ReplicaNode,
-      REGION: RegionNode,
-      LOAD_BALANCER: LoadBalancerNode,
-    }),
-    []
-  )
-
-  const edgeTypes = useMemo(
-    () => ({
-      smoothstep: SmoothstepEdge,
-    }),
-    []
-  )
-
-  const nodesInitialized = useNodesInitialized()
-  const [hasMeasuredLayout, setHasMeasuredLayout] = useState(false)
-
-  const setReactFlow = async ({ measured }: { measured: boolean }) => {
-    // Merge in React Flow's measured dimensions (if any) so dagre can use real
-    // heights instead of the first-paint fallbacks.
-    const measuredNodes = nodes.map((node) => {
-      const existing = reactFlow.getNode(node.id)
-      return existing?.measured ? { ...node, measured: existing.measured } : node
-    })
-    const graph = getDagreGraphLayout(measuredNodes, edges)
-    const { nodes: updatedNodes } = addRegionNodes(graph.nodes, graph.edges)
-    reactFlow.setNodes(updatedNodes)
-    reactFlow.setEdges(graph.edges)
-
-    // [Joshen] Odd fix to ensure that react flow snaps back to center when adding nodes
-    await timeout(1)
-    reactFlow.fitView({ maxZoom: 0.9, minZoom: 0.9 })
-    if (measured) setHasMeasuredLayout(true)
-  }
-
-  // First pass: lay out using fallback heights for any not-yet-measured nodes.
-  // The diagram is kept invisible until the measured pass below has run, so the
-  // user never sees the fallback positions.
-  // [Joshen] Just FYI this block is oddly triggering whenever we refocus on the viewport
-  // even if I change the dependency array to just data. Not blocker, just an area to optimize
-  useEffect(() => {
-    if (isSuccessReplicas && isSuccessLoadBalancers && nodes.length > 0 && view === 'flow') {
-      setReactFlow({ measured: false })
-    }
-  }, [isSuccessReplicas, isSuccessLoadBalancers, nodes, edges, view])
-
-  // Second pass: once React Flow has measured the nodes, re-run the layout so
-  // dagre uses real heights. Only `nodesInitialized` going true should trigger
-  // this — the first-pass effect above handles node/view changes.
-  const runMeasuredLayout = useEffectEvent(() => {
-    if (nodesInitialized && nodes.length > 0 && view === 'flow') {
-      setReactFlow({ measured: true })
-    }
-  })
-  useEffect(() => {
-    runMeasuredLayout()
-  }, [nodesInitialized])
-
   return (
-    <div className={cn('nowheel h-full')}>
+    <div className="nowheel h-full">
       <div
         className={`h-full w-full relative ${
           isSuccessReplicas && !isLoadingProject ? '' : 'flex items-center justify-center px-28'
         }`}
       >
         {(isLoading || isLoadingProject) && (
-          <Loader2 className="animate-spin text-foreground-light" />
+          <div role="status">
+            <span className="sr-only">Loading infrastructure...</span>
+            <Loader2
+              aria-hidden="true"
+              className="motion-safe:animate-spin text-foreground-light"
+            />
+          </div>
         )}
         {isError && <AlertError error={error} subject="Failed to retrieve replicas" />}
         {isSuccessReplicas && !isLoadingProject && (
@@ -259,32 +201,13 @@ const InstanceConfigurationUI = () => {
               </div>
             )}
             {view === 'flow' ? (
-              <ReactFlow
-                // FIXME: https://github.com/xyflow/xyflow/issues/4876
-                colorMode={'' as unknown as ColorMode}
-                fitView
-                fitViewOptions={{ minZoom: 0.9, maxZoom: 0.9 }}
-                // Keep the diagram invisible (but laid out, so nodes can be
-                // measured) until the measured-height layout pass has run.
-                className={cn(
-                  'instance-configuration transition-opacity duration-150',
-                  hasMeasuredLayout ? 'opacity-100' : 'opacity-0'
-                )}
-                zoomOnPinch={false}
-                zoomOnScroll={false}
-                nodesDraggable={false}
-                nodesConnectable={false}
-                zoomOnDoubleClick={false}
-                edgesFocusable={false}
-                edgesReconnectable={false}
-                defaultNodes={[]}
-                defaultEdges={[]}
+              <DiagramFlow
+                nodes={nodes}
+                edges={edges}
                 nodeTypes={nodeTypes}
                 edgeTypes={edgeTypes}
-                proOptions={{ hideAttribution: true }}
-              >
-                <Background color={backgroundPatternColor} />
-              </ReactFlow>
+                addGroupNodes={addRegionNodes}
+              />
             ) : (
               <MapView />
             )}
@@ -296,9 +219,22 @@ const InstanceConfigurationUI = () => {
 }
 
 export const InstanceConfiguration = () => {
+  const { isHighAvailability, isPending } = useHighAvailability()
+
+  // Wait for the project record so an HA project never briefly mounts the
+  // standard diagram (and fires its queries) before swapping.
+  if (isPending) {
+    return (
+      <div role="status" className="h-full w-full flex items-center justify-center">
+        <span className="sr-only">Loading infrastructure...</span>
+        <Loader2 aria-hidden="true" className="motion-safe:animate-spin text-foreground-light" />
+      </div>
+    )
+  }
+
   return (
     <ReactFlowProvider>
-      <InstanceConfigurationUI />
+      {isHighAvailability ? <HaInstanceConfiguration /> : <InstanceConfigurationUI />}
     </ReactFlowProvider>
   )
 }
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.utils.test.ts b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.utils.test.ts
new file mode 100644
index 00000000000..8a9f75fa4d3
--- /dev/null
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.utils.test.ts
@@ -0,0 +1,28 @@
+import { Edge, Node } from '@xyflow/react'
+import { describe, expect, it } from 'vitest'
+
+import { NODE_HEIGHT_FALLBACKS } from './InstanceConfiguration.constants'
+import { getDagreGraphLayout } from './InstanceConfiguration.utils'
+
+const makeNodes = (): Node[] => [
+  { id: 'primary', position: { x: 0, y: 0 }, data: {}, type: 'PRIMARY' },
+  { id: 'replica', position: { x: 0, y: 0 }, data: {}, type: 'READ_REPLICA' },
+]
+
+const edges: Edge[] = [{ id: 'primary-replica', source: 'primary', target: 'replica' }]
+
+// Vertical gap between a node's bottom edge and the next rank's top edge.
+const getRankGap = (nodes: Node[]) =>
+  nodes[1].position.y - (nodes[0].position.y + NODE_HEIGHT_FALLBACKS.PRIMARY)
+
+describe('getDagreGraphLayout', () => {
+  it('separates ranks by the default ranksep', () => {
+    const { nodes } = getDagreGraphLayout(makeNodes(), edges)
+    expect(getRankGap(nodes)).toBe(60)
+  })
+
+  it('separates ranks by a custom ranksep', () => {
+    const { nodes } = getDagreGraphLayout(makeNodes(), edges, { ranksep: 96 })
+    expect(getRankGap(nodes)).toBe(96)
+  })
+})
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.utils.ts b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.utils.ts
index 81e89e5ae2b..c4a2489f3db 100644
--- a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.utils.ts
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration.utils.ts
@@ -114,15 +114,19 @@ export const generateNodes = ({
   ]
 }
 
-const getDagreNodeHeight = (node: Node) => {
+export const getDagreNodeHeight = (node: Node) => {
   if (node.measured?.height) return node.measured.height
   return NODE_HEIGHT_FALLBACKS[node.type ?? ''] ?? 100
 }
 
-export const getDagreGraphLayout = (nodes: Node[], edges: Edge[]) => {
+export const getDagreGraphLayout = (
+  nodes: Node[],
+  edges: Edge[],
+  { ranksep = 60 }: { ranksep?: number } = {}
+) => {
   const dagreGraph = new dagre.graphlib.Graph()
   dagreGraph.setDefaultEdgeLabel(() => ({}))
-  dagreGraph.setGraph({ rankdir: 'TB', ranksep: 60, nodesep: NODE_SEP })
+  dagreGraph.setGraph({ rankdir: 'TB', ranksep, nodesep: NODE_SEP })
 
   nodes.forEach((node) => {
     dagreGraph.setNode(node.id, {
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceNode.tsx b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceNode.tsx
index 9689483c179..f01884557e4 100644
--- a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceNode.tsx
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceNode.tsx
@@ -21,6 +21,7 @@ import {
 } from 'ui'
 import { TimestampInfo } from 'ui-patterns/TimestampInfo'
 
+import { ComputeMetricsFooter } from './ComputeMetricsFooter'
 import {
   ERROR_STATES,
   INIT_PROGRESS,
@@ -32,7 +33,6 @@ import {
   ReplicaNodeData,
 } from './InstanceConfiguration.constants'
 import { formatSeconds } from './InstanceConfiguration.utils'
-import { metricColor } from './InstanceNode.utils'
 import { getReadReplicaPath } from '@/components/interfaces/Settings/Infrastructure/Infrastructure.utils'
 import { REPLICA_STATUS } from '@/components/interfaces/Settings/Infrastructure/ReadReplicas/ReadReplicas.constants'
 import { RegionFlag } from '@/components/ui/RegionFlag'
@@ -43,7 +43,6 @@ import {
   useReadReplicasStatusesQuery,
 } from '@/data/read-replicas/replicas-status-query'
 import { formatDatabaseID } from '@/data/read-replicas/replicas.utils'
-import { useComputeMetrics } from '@/hooks/analytics/useComputeMetrics'
 import { useIsFeatureEnabled } from '@/hooks/misc/useIsFeatureEnabled'
 import { useDatabaseSelectorStateSnapshot } from '@/state/database-selector'
 
@@ -92,25 +91,11 @@ export const LoadBalancerNode = ({ data }: NodeProps<Node<LoadBalancerData>>) =>
 export const PrimaryNode = ({ data }: NodeProps<Node<PrimaryNodeData>>) => {
   // [Joshen] Just FYI Handles cannot be conditionally rendered
   const { region, computeSize, numReplicas, numRegions, hasLoadBalancer } = data
-  const { ref } = useParams()
 
   const { projectHomepageShowInstanceSize } = useIsFeatureEnabled([
     'project_homepage:show_instance_size',
   ])
 
-  const {
-    cpu,
-    disk,
-    memory,
-    connections,
-    isLoading: metricsLoading,
-    isError: metricsError,
-  } = useComputeMetrics({
-    projectRef: ref,
-  })
-
-  const observabilityUrl = `/project/${ref}/observability/database`
-
   return (
     <>
       <Handle
@@ -171,43 +156,7 @@ export const PrimaryNode = ({ data }: NodeProps<Node<PrimaryNodeData>>) => {
             </p>
           </div>
         )}
-        <Tooltip>
-          <TooltipTrigger asChild>
-            <Link
-              href={observabilityUrl}
-              className="border-t px-3 py-2 hover:bg-surface-200 transition flex items-center gap-x-3 text-xs"
-            >
-              {metricsLoading ? (
-                <div className="h-3 w-44 rounded-sm bg-surface-300 animate-pulse" />
-              ) : metricsError ? (
-                <span className="text-foreground-lighter">Metrics unavailable</span>
-              ) : (
-                <>
-                  <span>
-                    CPU <span className={metricColor(cpu)}>{cpu.toFixed(0)}%</span>
-                  </span>
-                  <span className="text-foreground-lighter">·</span>
-                  <span>
-                    Disk <span className={metricColor(disk)}>{disk.toFixed(0)}%</span>
-                  </span>
-                  <span className="text-foreground-lighter">·</span>
-                  <span>
-                    RAM <span className={metricColor(memory)}>{memory.toFixed(0)}%</span>
-                  </span>
-                  {connections.max > 0 && (
-                    <>
-                      <span className="text-foreground-lighter">·</span>
-                      <span className="text-foreground-light">
-                        {connections.peak}/{connections.max} conns
-                      </span>
-                    </>
-                  )}
-                </>
-              )}
-            </Link>
-          </TooltipTrigger>
-          <TooltipContent side="bottom">Go to Database Report</TooltipContent>
-        </Tooltip>
+        <ComputeMetricsFooter />
       </div>
       <Handle
         type="source"
diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/useHaPooler.ts b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/useHaPooler.ts
new file mode 100644
index 00000000000..af64b7301b8
--- /dev/null
+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/useHaPooler.ts
@@ -0,0 +1,45 @@
+import { useQuery } from '@tanstack/react-query'
+import { useParams } from 'common'
+
+import { formatCellAsAvailabilityZone, getPoolerStatus } from './HaTopology.utils'
+import { AVAILABLE_REPLICA_REGIONS } from './InstanceConfiguration.constants'
+import { haClusterPoolersQueryOptions } from '@/data/ha-admin/ha-cluster-poolers-query'
+import { usePrimaryDatabase } from '@/data/read-replicas/replicas-query'
+import { useIsFeatureEnabled } from '@/hooks/misc/useIsFeatureEnabled'
+
+/**
+ * Subscribes to a single pooler's live state from the shared poolers query, so
+ * each node/edge updates on its own without re-laying-out the whole diagram.
+ */
+export const useHaPooler = ({ cell, name }: { cell?: string; name?: string }) => {
+  const { ref: projectRef } = useParams()
+
+  return useQuery({
+    ...haClusterPoolersQueryOptions({ projectRef }),
+    select: (data) =>
+      (data.poolers ?? []).find((pooler) => pooler.id?.cell === cell && pooler.id?.name === name),
+  })
+}
+
+/**
+ * Everything a pooler node card displays. Region and compute size aren't in
+ * multiadmin — they come from the primary database row. HA locks compute to
+ * one project-level size, so the primary's size is correct for every node in
+ * the cluster.
+ */
+export const useHaPoolerCard = ({ cell, name }: { cell?: string; name?: string }) => {
+  const { ref: projectRef } = useParams()
+  const { projectHomepageShowInstanceSize } = useIsFeatureEnabled([
+    'project_homepage:show_instance_size',
+  ])
+
+  const { database: primary } = usePrimaryDatabase({ projectRef })
+  const { data: pooler } = useHaPooler({ cell, name })
+
+  return {
+    status: pooler !== undefined ? getPoolerStatus(pooler) : undefined,
+    availabilityZone: formatCellAsAvailabilityZone(cell),
+    computeSize: projectHomepageShowInstanceSize ? primary?.size : undefined,
+    primaryRegion: AVAILABLE_REPLICA_REGIONS.find((r) => primary?.region.includes(r.region)),
+  }
+}
diff --git a/apps/studio/components/ui/ReactFlow/EdgeVisual.tsx b/apps/studio/components/ui/ReactFlow/EdgeVisual.tsx
new file mode 100644
index 00000000000..88c56574656
--- /dev/null
+++ b/apps/studio/components/ui/ReactFlow/EdgeVisual.tsx
@@ -0,0 +1,88 @@
+import { ArrowRight, Loader2, Square, X, type LucideIcon } from 'lucide-react'
+import { cn } from 'ui'
+
+export interface ReplicationState {
+  isComingUp: boolean
+  isReplicating: boolean
+  isFailed: boolean
+}
+
+export interface EdgeVisual {
+  Icon: LucideIcon
+  // CSS color shared by the icon and the connecting line so they always match.
+  color: string
+  opacity: number
+  dashArray: string
+  strokeWidth: number
+  shouldAnimate: boolean
+  shouldSpin?: boolean
+  isFilled?: boolean
+}
+
+// Picks the icon + line appearance for a replication state. Both the icon and the line are derived
+// here from the same state so they always stay in sync. We deliberately don't surface lag: the line
+// just communicates whether data is moving, stopped, starting, or broken.
+export const getEdgeVisual = ({
+  isComingUp,
+  isReplicating,
+  isFailed,
+}: ReplicationState): EdgeVisual => {
+  if (isFailed) {
+    return {
+      Icon: X,
+      color: 'hsl(var(--destructive-default))',
+      opacity: 1,
+      dashArray: '5 5',
+      shouldAnimate: false,
+      strokeWidth: 4,
+    }
+  }
+  if (isComingUp) {
+    return {
+      Icon: Loader2,
+      color: 'var(--foreground-light)',
+      opacity: 1,
+      dashArray: '5',
+      strokeWidth: 2,
+      shouldAnimate: true,
+      shouldSpin: true,
+    }
+  }
+  if (isReplicating) {
+    return {
+      Icon: ArrowRight,
+      color: 'hsl(var(--brand-default))',
+      opacity: 1,
+      dashArray: '5',
+      strokeWidth: 2,
+      shouldAnimate: true,
+    }
+  }
+  return {
+    Icon: Square,
+    color: 'var(--foreground-lighter)',
+    opacity: 0.5,
+    dashArray: '5 5',
+    strokeWidth: 2,
+    shouldAnimate: false,
+    isFilled: true,
+  }
+}
+
+/** The round icon chip rendered mid-edge, bordered in the edge's color. */
+export const EdgeVisualChip = ({ visual }: { visual: EdgeVisual }) => {
+  const { Icon, color, shouldSpin, isFilled } = visual
+
+  return (
+    <div
+      className="w-6 h-6 rounded-full flex items-center justify-center border bg-surface-100"
+      style={{ borderColor: color }}
+    >
+      <Icon
+        size={14}
+        className={cn(shouldSpin && 'motion-safe:animate-spin')}
+        style={{ color, fill: isFilled ? color : undefined }}
+      />
+    </div>
+  )
+}
diff --git a/apps/studio/data/ha-admin/get-ha-admin.ts b/apps/studio/data/ha-admin/get-ha-admin.ts
new file mode 100644
index 00000000000..53b205fcbd8
--- /dev/null
+++ b/apps/studio/data/ha-admin/get-ha-admin.ts
@@ -0,0 +1,41 @@
+import { z } from 'zod'
+
+import { get, handleError } from '@/data/fetchers'
+
+/**
+ * Read-only slices of the multiadmin API, surfaced through the mgmt-api
+ * `/ha-admin` GET passthrough. The passthrough is a catch-all proxy, so these
+ * paths aren't in Studio's generated OpenAPI types — each resource validates
+ * the response against its own zod schema instead.
+ *
+ * mgmt-api forwards `/ha-admin/v1/<x>` → `/multiadmin/v1/<x>`, which the
+ * project edge gateway rewrites to multiadmin's `/api/v1/<x>`.
+ */
+export async function getHaAdmin(
+  projectRef: string | undefined,
+  subPath: string,
+  signal?: AbortSignal
+): Promise<unknown> {
+  if (!projectRef) throw new Error('projectRef is required')
+
+  const { data, error } = await get(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- off-schema passthrough path
+    `/platform/projects/${projectRef}/ha-admin/v1/${subPath}` as any,
+    { signal }
+  )
+
+  if (error) handleError(error)
+  return data
+}
+
+/**
+ * Validates a passthrough response, surfacing a readable error (which lands in
+ * the diagram's AlertError fallback) instead of a raw zod issue dump.
+ */
+export function parseHaAdminResponse<T extends z.ZodTypeAny>(schema: T, data: unknown): z.infer<T> {
+  const parsed = schema.safeParse(data)
+  if (!parsed.success) {
+    throw new Error('Received an unexpected response from the cluster admin API')
+  }
+  return parsed.data
+}
diff --git a/apps/studio/data/ha-admin/ha-cluster-cells-query.ts b/apps/studio/data/ha-admin/ha-cluster-cells-query.ts
new file mode 100644
index 00000000000..d5571f502c3
--- /dev/null
+++ b/apps/studio/data/ha-admin/ha-cluster-cells-query.ts
@@ -0,0 +1,27 @@
+import { queryOptions } from '@tanstack/react-query'
+import { z } from 'zod'
+
+import { getHaAdmin, parseHaAdminResponse } from './get-ha-admin'
+import { haAdminKeys } from './keys'
+import { IS_PLATFORM } from '@/lib/constants'
+import type { ResponseError } from '@/types'
+
+export type HaClusterCellsVariables = { projectRef?: string }
+export type HaClusterCellsError = ResponseError
+
+// Every field is optional because proto3 JSON omits zero values.
+const haClusterCellsResponseSchema = z.object({ names: z.array(z.string()).optional() })
+
+async function getHaClusterCells({ projectRef }: HaClusterCellsVariables, signal?: AbortSignal) {
+  const data = await getHaAdmin(projectRef, 'cells', signal)
+  return parseHaAdminResponse(haClusterCellsResponseSchema, data)
+}
+
+export type HaClusterCellsData = Awaited<ReturnType<typeof getHaClusterCells>>
+
+export const haClusterCellsQueryOptions = ({ projectRef }: HaClusterCellsVariables) =>
+  queryOptions({
+    queryKey: haAdminKeys.cells(projectRef),
+    queryFn: ({ signal }) => getHaClusterCells({ projectRef }, signal),
+    enabled: IS_PLATFORM && typeof projectRef !== 'undefined',
+  })
diff --git a/apps/studio/data/ha-admin/ha-cluster-databases-query.ts b/apps/studio/data/ha-admin/ha-cluster-databases-query.ts
new file mode 100644
index 00000000000..15cfd3adfb1
--- /dev/null
+++ b/apps/studio/data/ha-admin/ha-cluster-databases-query.ts
@@ -0,0 +1,30 @@
+import { queryOptions } from '@tanstack/react-query'
+import { z } from 'zod'
+
+import { getHaAdmin, parseHaAdminResponse } from './get-ha-admin'
+import { haAdminKeys } from './keys'
+import { IS_PLATFORM } from '@/lib/constants'
+import type { ResponseError } from '@/types'
+
+export type HaClusterDatabasesVariables = { projectRef?: string }
+export type HaClusterDatabasesError = ResponseError
+
+// Every field is optional because proto3 JSON omits zero values.
+const haClusterDatabasesResponseSchema = z.object({ names: z.array(z.string()).optional() })
+
+async function getHaClusterDatabases(
+  { projectRef }: HaClusterDatabasesVariables,
+  signal?: AbortSignal
+) {
+  const data = await getHaAdmin(projectRef, 'databases', signal)
+  return parseHaAdminResponse(haClusterDatabasesResponseSchema, data)
+}
+
+export type HaClusterDatabasesData = Awaited<ReturnType<typeof getHaClusterDatabases>>
+
+export const haClusterDatabasesQueryOptions = ({ projectRef }: HaClusterDatabasesVariables) =>
+  queryOptions({
+    queryKey: haAdminKeys.databases(projectRef),
+    queryFn: ({ signal }) => getHaClusterDatabases({ projectRef }, signal),
+    enabled: IS_PLATFORM && typeof projectRef !== 'undefined',
+  })
diff --git a/apps/studio/data/ha-admin/ha-cluster-gateways-query.ts b/apps/studio/data/ha-admin/ha-cluster-gateways-query.ts
new file mode 100644
index 00000000000..b8e8037b3aa
--- /dev/null
+++ b/apps/studio/data/ha-admin/ha-cluster-gateways-query.ts
@@ -0,0 +1,39 @@
+import { queryOptions } from '@tanstack/react-query'
+import { z } from 'zod'
+
+import { getHaAdmin, parseHaAdminResponse } from './get-ha-admin'
+import { haAdminKeys } from './keys'
+import { IS_PLATFORM } from '@/lib/constants'
+import type { ResponseError } from '@/types'
+
+export type HaClusterGatewaysVariables = { projectRef?: string }
+export type HaClusterGatewaysError = ResponseError
+
+// Every field is optional because proto3 JSON omits zero values.
+const multigatewaySchema = z.object({
+  id: z.object({ cell: z.string().optional(), name: z.string().optional() }).optional(),
+  hostname: z.string().optional(),
+})
+
+const haClusterGatewaysResponseSchema = z.object({
+  gateways: z.array(multigatewaySchema).optional(),
+})
+
+export type Multigateway = z.infer<typeof multigatewaySchema>
+
+async function getHaClusterGateways(
+  { projectRef }: HaClusterGatewaysVariables,
+  signal?: AbortSignal
+) {
+  const data = await getHaAdmin(projectRef, 'gateways', signal)
+  return parseHaAdminResponse(haClusterGatewaysResponseSchema, data)
+}
+
+export type HaClusterGatewaysData = Awaited<ReturnType<typeof getHaClusterGateways>>
+
+export const haClusterGatewaysQueryOptions = ({ projectRef }: HaClusterGatewaysVariables) =>
+  queryOptions({
+    queryKey: haAdminKeys.gateways(projectRef),
+    queryFn: ({ signal }) => getHaClusterGateways({ projectRef }, signal),
+    enabled: IS_PLATFORM && typeof projectRef !== 'undefined',
+  })
diff --git a/apps/studio/data/ha-admin/ha-cluster-poolers-query.ts b/apps/studio/data/ha-admin/ha-cluster-poolers-query.ts
new file mode 100644
index 00000000000..b88b12cbc14
--- /dev/null
+++ b/apps/studio/data/ha-admin/ha-cluster-poolers-query.ts
@@ -0,0 +1,64 @@
+import { queryOptions } from '@tanstack/react-query'
+import { z } from 'zod'
+
+import { getHaAdmin, parseHaAdminResponse } from './get-ha-admin'
+import { haAdminKeys } from './keys'
+import { IS_PLATFORM } from '@/lib/constants'
+import type { ResponseError } from '@/types'
+
+export type HaClusterPoolersVariables = { projectRef?: string }
+export type HaClusterPoolersError = ResponseError
+
+// Hand-modelled subset of multiadmin's OpenAPI spec. Every field is optional
+// because proto3 JSON omits zero values, and enum-shaped fields stay plain
+// strings (expected values in comments) so new proto values degrade gracefully
+// instead of failing the whole parse.
+const multipoolerSchema = z.object({
+  id: z.object({ cell: z.string().optional(), name: z.string().optional() }).optional(),
+  shardKey: z
+    .object({
+      database: z.string().optional(),
+      tableGroup: z.string().optional(),
+      shard: z.string().optional(),
+    })
+    .optional(),
+  // 'UNKNOWN' | 'PRIMARY' | 'REPLICA' | 'DRAINED' — deprecated (derived, not
+  // authoritative), prefer `routingState.role`
+  type: z.string().optional(),
+  // 'SERVING' | 'DISABLED' | 'DRAINING'
+  servingStatus: z.string().optional(),
+  hostname: z.string().optional(),
+  lifecycleStatus: z.object({ status: z.string().optional() }).optional(),
+  routingState: z
+    .object({
+      role: z.string().optional(),
+      // proto int64s, serialized as strings in JSON
+      rule: z
+        .object({ coordinatorTerm: z.string().optional(), leaderSubterm: z.string().optional() })
+        .optional(),
+    })
+    .optional(),
+})
+
+const haClusterPoolersResponseSchema = z.object({
+  poolers: z.array(multipoolerSchema).optional(),
+})
+
+export type Multipooler = z.infer<typeof multipoolerSchema>
+
+async function getHaClusterPoolers(
+  { projectRef }: HaClusterPoolersVariables,
+  signal?: AbortSignal
+) {
+  const data = await getHaAdmin(projectRef, 'poolers', signal)
+  return parseHaAdminResponse(haClusterPoolersResponseSchema, data)
+}
+
+export type HaClusterPoolersData = Awaited<ReturnType<typeof getHaClusterPoolers>>
+
+export const haClusterPoolersQueryOptions = ({ projectRef }: HaClusterPoolersVariables) =>
+  queryOptions({
+    queryKey: haAdminKeys.poolers(projectRef),
+    queryFn: ({ signal }) => getHaClusterPoolers({ projectRef }, signal),
+    enabled: IS_PLATFORM && typeof projectRef !== 'undefined',
+  })
diff --git a/apps/studio/data/ha-admin/keys.ts b/apps/studio/data/ha-admin/keys.ts
new file mode 100644
index 00000000000..3193018650a
--- /dev/null
+++ b/apps/studio/data/ha-admin/keys.ts
@@ -0,0 +1,9 @@
+export const haAdminKeys = {
+  cells: (projectRef: string | undefined) => ['projects', projectRef, 'ha-admin', 'cells'] as const,
+  databases: (projectRef: string | undefined) =>
+    ['projects', projectRef, 'ha-admin', 'databases'] as const,
+  poolers: (projectRef: string | undefined) =>
+    ['projects', projectRef, 'ha-admin', 'poolers'] as const,
+  gateways: (projectRef: string | undefined) =>
+    ['projects', projectRef, 'ha-admin', 'gateways'] as const,
+}
diff --git a/apps/studio/pages/project/[ref]/database/replication/index.tsx b/apps/studio/pages/project/[ref]/database/replication/index.tsx
index 296fcd4f3e2..e444bbad613 100644
--- a/apps/studio/pages/project/[ref]/database/replication/index.tsx
+++ b/apps/studio/pages/project/[ref]/database/replication/index.tsx
@@ -12,9 +12,9 @@ import { GenericSkeletonLoader } from 'ui-patterns/ShimmeringLoader'
 import { ReadReplicasMovedCallout } from '@/components/interfaces/Database/Replication/DestinationPanel/ReadReplicasMovedCallout'
 import { Destinations } from '@/components/interfaces/Database/Replication/Destinations'
 import { ReplicationDiagram } from '@/components/interfaces/Database/Replication/ReplicationDiagram'
+import { InstanceConfiguration } from '@/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/InstanceConfiguration'
 import DatabaseLayout from '@/components/layouts/DatabaseLayout/DatabaseLayout'
 import { DefaultLayout } from '@/components/layouts/DefaultLayout'
-import { HighAvailabilityDisabledEmptyState } from '@/components/ui/HighAvailability/HighAvailabilityDisabledEmptyState'
 import { UnknownInterface } from '@/components/ui/UnknownInterface'
 import { useHighAvailability } from '@/hooks/misc/useHighAvailability'
 import { useIsFeatureEnabled } from '@/hooks/misc/useIsFeatureEnabled'
@@ -33,12 +33,26 @@ const DatabaseReplicationPage: NextPageWithLayout = () => {
 
   if (isHighAvailability) {
     return (
-      <div className="flex h-full w-full items-center justify-center p-6">
-        <HighAvailabilityDisabledEmptyState
-          title="Replication unavailable on High Availability projects"
-          description="We're working to bring replication to High Availability projects. Contact support if this is blocking your work."
-        />
-      </div>
+      <>
+        <PageHeader size="large">
+          <PageHeaderMeta>
+            <PageHeaderSummary>
+              <PageHeaderTitle>Replication</PageHeaderTitle>
+              <PageHeaderDescription>High Availability cluster topology</PageHeaderDescription>
+            </PageHeaderSummary>
+          </PageHeaderMeta>
+        </PageHeader>
+
+        <PageContainer size="large">
+          <PageSection>
+            <PageSectionContent>
+              <div className="relative h-[500px] w-full overflow-hidden rounded-md border border-muted">
+                <InstanceConfiguration />
+              </div>
+            </PageSectionContent>
+          </PageSection>
+        </PageContainer>
+      </>
     )
   }
 
diff --git a/apps/studio/styles/reactflow.css b/apps/studio/styles/reactflow.css
index 62e1a494528..89eb05a4758 100644
--- a/apps/studio/styles/reactflow.css
+++ b/apps/studio/styles/reactflow.css
@@ -9,6 +9,12 @@
   }
 }
 
+@media (prefers-reduced-motion: reduce) {
+  .react-flow__edge.animated path {
+    animation: none;
+  }
+}
+
 .map-path {
   animation: dash 8s linear infinite;
 }