diff --git a/apps/blog/content/blog/designing-a-streaming-api-for-serverless-postgres/index.mdx b/apps/blog/content/blog/designing-a-streaming-api-for-serverless-postgres/index.mdx
new file mode 100644
index 0000000000..ff279a2d55
--- /dev/null
+++ b/apps/blog/content/blog/designing-a-streaming-api-for-serverless-postgres/index.mdx
@@ -0,0 +1,140 @@
+---
+title: "Designing a Streaming API for Serverless Postgres"
+slug: "designing-a-streaming-api-for-serverless-postgres"
+date: "2026-09-16"
+authors:
+  - "Ankur Datta"
+metaTitle: "Designing a Streaming API for Serverless Postgres"
+metaDescription: "How Prisma Postgres carries SQL over HTTP and WebSockets without buffering whole results: the API contract, the streamed Bind and DataRow paths, backpressure, and the limits that remain."
+excerpt: "A serverless access path that handles database results incrementally."
+heroImagePath: "/designing-a-streaming-api-for-serverless-postgres/imgs/hero.svg"
+heroImageAlt: "Cover: a database tile and a client tile connected by a channel in which small row chunks move one at a time, a gauge labeled bounded memory above and a dashed arrow labeled a slow client slows the sender below, under the headline Stream rows, not results."
+metaImagePath: "/designing-a-streaming-api-for-serverless-postgres/imgs/meta.png"
+tags:
+  - "prisma-postgres"
+  - "education"
+  - "platform"
+series: prisma-postgres-connectivity
+seriesIndex: 3
+---
+
+_This is the third post in a four-part series on how Prisma Postgres handles database connectivity. [Post 1](/why-prisma-postgres-needs-a-gateway) covered the gateway; [Post 2](/why-serverless-apps-are-hard-on-postgres-connections) covered connection pooling. This one is about reaching Postgres from runtimes where a Postgres socket is not the right tool._
+
+After reading this post, you'll understand what an API has to promise in order to carry Postgres interactions over HTTP and WebSockets, and how designing that API around streaming changes what the gateway has to hold in memory.
+
+Start from a constraint. Vercel's Edge runtime exposes a subset of Web APIs: `fetch`, `Request`, `Response`, and a short list of Node modules that does not include `net` or `tls`. There is no way to open a TCP socket from it, which means no way to speak the Postgres protocol, which means no Postgres driver. Cloudflare Workers can open TCP sockets, but a socket cannot be shared across requests, and every request pays connection setup again. Browsers cannot open a raw socket at all. And even on a runtime with a full Node API, a request-scoped function is an odd home for a protocol built around sessions that expect to live for minutes or hours.
+
+Post 2 established that connection lifecycle pressure is one problem. This is a different one: the transport itself. The question is how to give code in those environments a database it can talk to using the tools it has, `fetch` and WebSockets, without giving up what makes Postgres useful.
+
+## Two ways to build it
+
+There are two broad designs, and the difference between them is where the Postgres protocol gets spoken.
+
+**Wrap the wire protocol.** Keep the client speaking real Postgres messages and carry those bytes over a WebSocket to a relay that opens the TCP connection on the client's behalf. The client is a normal Postgres driver with a different socket underneath. Every Postgres feature works because nothing about the protocol changed. The cost is that the relay is protocol-blind and the client still has to do everything a Postgres driver does, including a full connection handshake per WebSocket.
+
+**Define a database API.** Give the client a smaller, purpose-built contract: "run this SQL with these parameters, give me rows back", carried in whatever framing the transport supports. The server speaks Postgres on the client's behalf. Now the server can pool, meter, and stream, but every Postgres feature the API does not model is unavailable, and the API's own limits become the application's limits.
+
+Neon's serverless driver is a useful case study because it ships both. At version 1.1.0 (released April 2026), its [documentation](https://neon.com/docs/serverless/serverless-driver) describes an HTTP path, `neon()`, for "single, non-interactive transactions" or a batch of queries wrapped in one non-interactive transaction, and a WebSocket path, `Pool` and `Client`, for sessions and interactive transactions with node-postgres compatibility. The WebSocket path is the wrapped-protocol design: the driver talks Postgres over a WebSocket to a small open-source Go relay, `wsproxy`, that forwards bytes to the database. The HTTP path is a database API: the driver POSTs JSON to an `/sql` endpoint and reads a JSON response body. In the driver's source the HTTP client awaits the full response and parses it as JSON, and the documentation lists a 64 MB maximum on request and response size. Neither of those is a criticism; they are the natural shape of a request/response RPC. But they define the tradeoff: the HTTP path is stateless and easy to use from any runtime, and it holds a whole result in memory on both sides.
+
+Prisma chose the database-API design for its serverless path, and then spent most of the engineering effort on not holding whole results in memory. The rest of this post is about why and how.
+
+## What a fully buffered query RPC costs
+
+Nothing about HTTP requires buffering. An HTTP response is a byte stream; a client can read it incrementally and a server can write it incrementally. The buffering shows up when the API contract says "the response is one JSON document", because then the server has to know the whole document before it can send a valid one, and the client has to receive the whole document before it can parse it.
+
+For a query that returns twenty rows this is invisible. Two situations make it expensive.
+
+The first is a large result. A report query that returns a few hundred thousand rows, or a single row holding a large `bytea` or `text` value, becomes a few hundred megabytes of JSON on the server before a single byte reaches the client. That memory belongs to the tenant who ran the query, but it is taken from a process shared with other tenants: the noisy-neighbor problem from Post 1, now with a buffer attached to it.
+
+The second is a slow consumer. If the server must buffer until the query completes, a query that produces rows slowly holds memory for its whole duration, and a client that reads the response slowly holds the server's copy until it finishes. Both push a shared process toward caps: a cap on how long a query may run, and a cap on how large a response may be.
+
+Prisma has operated a system with exactly this shape. Accelerate, the successor to the Data Proxy described in Post 2, carries Prisma's query protocol over HTTPS to a query engine near the database, and its [documentation](https://www.prisma.io/docs/accelerate/faq) publishes per-plan limits on query duration (10 to 60 seconds), interactive transaction duration, and response size (5 to 20 MB). Caps like those are the natural consequence of the shape: an engine that materializes results for a JSON response has to bound what it will materialize. The team also learned that scaling the engine's connection pool horizontally, adding instances to spread the load, produced user-visible slowness rather than smoothing it out, and the replacement they designed scales vertically alongside each database VM instead. The lesson that carried into the next design is not "HTTP was wrong". It is that a contract which forces the server to hold whole results makes caps unavoidable, and that the fix has to be in the contract.
+
+## The contract Prisma built
+
+The serverless path lives inside the same gateway process that terminates TCP connections, which matters for Post 4. It exposes two transports:
+
+- **HTTP** at `/v0/statement`: one statement per request. The request is a multipart body carrying a JSON descriptor part (the SQL, and how to render the result) followed by one part per parameter that is too large to inline. The response is a stream of newline-delimited JSON by default.
+- **WebSocket** at `/v0/session`: a persistent session that carries many statements over one socket, with an authentication message first, then statements and results. Results come back in the order statements were sent.
+
+Both are what the [`@prisma/ppg` driver](https://www.prisma.io/docs/postgres/database/serverless-driver) speaks, and both are pooled by default at the gateway, so a serverless function gets the pooling from Post 2 without configuring it. At the protocol level a request can opt out of pooling with a header, though the driver does not expose that as a documented option.
+
+The contract is deliberately small: a statement is a SQL string plus parameters, and a result is a column description, a sequence of rows, and a completion or an error. Sessions and transactions exist on the WebSocket path because a transaction needs the same backend connection for `BEGIN` through `COMMIT`. The driver's `transaction()` opens a session, sends `BEGIN`, runs your callback's statements, and sends `COMMIT` or `ROLLBACK` on that session. Its `batch()` is a transaction that runs statements in sequence; there is no separate batch endpoint on the server.
+
+The parts that took engineering are on either end of that contract: how the gateway turns a request into Postgres messages without reading the request into memory, and how it turns Postgres messages into a response without reading the result into memory.
+
+## Request side: forging the protocol from a stream
+
+When a statement arrives, the gateway has to speak the Postgres [extended query protocol](https://www.postgresql.org/docs/current/protocol-flow.html) on the client's behalf. A statement with no parameters becomes a single simple `Query` message. A statement with parameters becomes the extended sequence: `Parse` (the SQL), `Bind` (the parameter values), `Describe`, `Execute`, and `Sync`.
+
+`Bind` is the message that carries parameter values, and a parameter can be large. The naive implementation reads all parameters, computes the message length, and writes the message. The gateway instead builds `Bind` as a chain of readers: the header, then for each parameter a length prefix followed by a reader over that parameter's bytes, then the footer. Small parameters are inline in the JSON descriptor. A parameter above a size threshold (the driver's threshold is one kilobyte) arrives as its own multipart part or WebSocket frame, and the gateway's reader for that parameter pulls from the transport as the message is written to the database. Postgres requires the message length up front, so the client declares each streamed parameter's size in the descriptor, which lets the gateway stamp the header before it has read a single parameter byte.
+
+The result is that a parameter value flows from the client's request body, through the gateway, into the database's socket in bounded chunks. A one-kilobyte parameter and a hundred-megabyte one take the same code path and the same amount of gateway memory.
+
+## Response side: transcoding rows as they arrive
+
+Coming back, the database sends a `RowDescription` message, then one `DataRow` message per row, then `CommandComplete` and `ReadyForQuery`. A `DataRow` is a field count followed by, for each field, a four-byte length and that many bytes. The gateway needs to look inside it, because the client expects JSON, not Postgres binary framing. But a single field can be larger than any sane buffer.
+
+So the gateway reads `DataRow` structurally without materializing it. It reads the field count, then for each field reads the length and wraps the next that-many bytes of the upstream socket in a bounded reader. That reader is handed to the encoder, which writes the field to the client transport as it goes: text fields through a streaming JSON escaper, `bytea` fields through a streaming base64 transform. The upstream read and the client write interleave field by field. On the HTTP path the encoder flushes its output at a threshold; on the WebSocket path each result frame is sent as its own message. At no point does a whole row, let alone a whole result, exist in gateway memory.
+
+```mermaid
+sequenceDiagram
+%% Streaming path of the serverless API, response side, showing how a slow client
+%% propagates backpressure to the database. Conceptual; based on the gateway's
+%% field-by-field DataRow transcoding (ignite pg-protocol catalog 1.4; transports 6.2)
+%% and the redesign's coupled copy loops (pdp-metal pg-api-adapter design).
+    participant App as Serverless function<br/>(@prisma/ppg)
+    participant GW as Gateway<br/>(API adapter + pipeline)
+    participant DB as PostgreSQL
+
+    App->>GW: POST /v0/statement<br/>(descriptor, streamed parameters)
+    GW->>DB: Parse, Bind, Describe,<br/>Execute, Sync
+    Note over GW,DB: parameter bytes stream through as the client sends them
+    DB-->>GW: RowDescription
+    GW-->>App: column metadata
+    loop each row
+        DB-->>GW: DataRow
+        Note over GW: one field at a time: bounded read, encode, write
+        GW-->>App: row (NDJSON line)
+    end
+    Note over App,DB: a slow client blocks the gateway's write, so it stops reading; the TCP window closes and the database stops sending
+    DB-->>GW: CommandComplete, ReadyForQuery
+    GW-->>App: completion
+```
+
+_Response streaming on the serverless API. Each DataRow is read one field at a time and written to the client as it is decoded, so a client that reads slowly stops the gateway reading the database socket. Conceptual sequence; message names are the real protocol messages._
+
+The diagram shows the property this buys, which is backpressure, and it is worth spelling out in plain language. If the client reads slowly, the encoder's write to the client transport blocks. Because the encoder is what is pulling bytes off the upstream socket, that read stops too. Because the gateway has stopped reading, the socket's receive buffer fills, TCP's window closes, and the database stops sending. A slow client slows the database down instead of filling the gateway with rows the client has not asked for yet. The same coupling runs the other way on the request side: a slow database blocks the gateway's write, which stops it reading the client's request body, which stops the client sending parameter bytes. There is no queue in the middle to grow, and that absence is the design.
+
+Precision matters here, because backpressure is one of those words that gets claimed more often than it is delivered. In the gateway implementation that serves production today, the response side is a pull iterator that the transport drains, and the coupling above holds along that pull. On the WebSocket path, however, the request side accepts pipelined statements into a queue that has no bound. A client that sends statements faster than the database answers them grows that queue, and the redesign in Post 4 replaces it with a bounded one that blocks the sender. On the client side, the driver's HTTP path streams rows to your code as they arrive, while its WebSocket path buffers rows in the driver if your code consumes them more slowly than the socket delivers them. Streaming is end to end on the HTTP path today, and end to end on the WebSocket path once the bounded queue lands.
+
+## On the client: streaming first, collection optional
+
+The driver exposes results as a `CollectableIterator`: an async iterator you can consume row by row, with a `collect()` method that gathers everything into an array when a result is small and an array is what you want. Streaming is the default representation and collection is a convenience on top of it, rather than the other way around. That ordering is the client-side expression of the same contract: the API never promises that a result fits in memory, so the driver never assumes it.
+
+Two things fall out of the session design for free, and both deserve a precise description.
+
+**Pipelining.** On a WebSocket session, the driver sends statements without waiting for the previous result, and results come back in send order. This removes a round trip of latency per statement for a sequence of independent statements. It does not run them in parallel: Postgres executes statements on a connection in the order it receives them, exactly as [libpq's pipeline mode](https://www.postgresql.org/docs/current/libpq-pipeline-mode.html) describes. Pipelining saves waiting, not execution time.
+
+**Transactions as ordinary statements.** Because results are ordered, the driver can send `BEGIN` and the first statement of a transaction without waiting for `BEGIN` to be acknowledged. A transaction is nothing more than statements that happen to share a session. That is also why interactive transactions belong on the WebSocket path and not the HTTP one: HTTP requests do not share a backend connection, so `BEGIN` in one request and `COMMIT` in another would land on different backends through the pool.
+
+## What still bounds a request
+
+Removing whole-result buffering removes one family of caps: there is no gateway limit on how many rows a result may contain or how large a field may be, because the gateway never holds them. It is not the same as saying nothing is limited, and the remaining limits are worth listing plainly.
+
+- Pooled connections, which the serverless path uses by default, carry the [10-minute query timeout](https://www.prisma.io/docs/postgres/database/connection-pooling) documented for pooled traffic. Work that needs longer belongs on a direct connection.
+- The gateway arms per-operation read and write deadlines and an idle timeout on every connection, so a stalled client or database is torn down rather than held forever. Those are operational settings, not contract guarantees, and they are not published as product limits.
+- The gateway does cap small control messages: the statement descriptor and the session authentication message have fixed size limits, and the protocol's own control messages are materialized into a bounded buffer. Only row data and parameter values are unbounded, and only because they are never materialized.
+- Session state on pooled connections is subject to the same transaction-mode rules as Post 2 described.
+
+Two Postgres features are outside the contract. `COPY` is not exposed through the statement API, and asynchronous notifications (`LISTEN`/`NOTIFY`) need a direct connection. Both are cases where the wrapped-protocol design wins, and the tradeoff is the one stated at the top: a database API models what it models.
+
+## A note on where this goes
+
+The team has discussed the fact that a contract this small, framed over HTTP and WebSockets, could be implemented by a driver in any language, and has sketched what a JDBC driver might look like. Nothing beyond the TypeScript driver exists today, and there is no committed plan, so treat that as a direction the design leaves open rather than a roadmap item.
+
+## Takeaway
+
+A serverless database API has to promise something narrower than the Postgres protocol, and the value of the design lives in choosing that contract carefully. By making the response a stream of rows rather than a document, and by building the request as a stream of parameters rather than a message assembled in memory, Prisma's gateway carries arbitrarily large results and parameters through a shared process without buffering them, and a slow consumer slows its producer instead of consuming shared memory. What remains bounded is bounded on purpose: control messages, timeouts, and the transaction-mode rules of the pool behind it.
+
+The gateway now has two ways to speak Postgres: forwarding a client's own messages on the TCP path, and forging messages from an API request on the serverless path. For a long time those were two separate implementations of the same protocol inside one process. Unifying them is the subject of the final post.
diff --git a/apps/blog/content/blog/unifying-tcp-and-serverless-connectivity-in-prisma-postgres/index.mdx b/apps/blog/content/blog/unifying-tcp-and-serverless-connectivity-in-prisma-postgres/index.mdx
new file mode 100644
index 0000000000..e044cca3a4
--- /dev/null
+++ b/apps/blog/content/blog/unifying-tcp-and-serverless-connectivity-in-prisma-postgres/index.mdx
@@ -0,0 +1,132 @@
+---
+title: "Unifying TCP and Serverless Connectivity in Prisma Postgres"
+slug: "unifying-tcp-and-serverless-connectivity-in-prisma-postgres"
+date: "2026-09-16"
+authors:
+  - "Ankur Datta"
+metaTitle: "Unifying TCP and Serverless Connectivity in Prisma Postgres"
+metaDescription: "Why Prisma separated connection lifecycle from protocol processing in its Postgres gateway, what the shared pipeline looks like, how the embedded pool reads transaction state, and which benefits are verified today."
+excerpt: "A shared protocol pipeline and the connection lifecycle around it."
+heroImagePath: "/unifying-tcp-and-serverless-connectivity-in-prisma-postgres/imgs/hero.svg"
+heroImageAlt: "Cover: a lifecycle band listing accept, tls, auth, resolve, and teardown sits above two path tiles, tcp and http/ws, whose lines merge into one highlighted pipeline tile labeled shared handlers and continue to a database icon, under the headline Two paths, one pipeline."
+metaImagePath: "/unifying-tcp-and-serverless-connectivity-in-prisma-postgres/imgs/meta.png"
+tags:
+  - "prisma-postgres"
+  - "education"
+  - "platform"
+series: prisma-postgres-connectivity
+seriesIndex: 4
+---
+
+_This is the final post in a four-part series on how Prisma Postgres handles database connectivity. [Post 1](/why-prisma-postgres-needs-a-gateway) introduced the gateway, [Post 2](/why-serverless-apps-are-hard-on-postgres-connections) covered pooling, and [Post 3](/designing-a-streaming-api-for-serverless-postgres) covered the streaming serverless API. This one is about the architecture that ties them together, and it describes work that is still landing._
+
+After reading this post, you'll understand why the team separated protocol processing from connection lifecycle, what the shared pipeline that came out of that separation looks like, and which of its benefits are verified today versus planned.
+
+Start with the idea, because everything else follows from it. A database proxy does two unrelated jobs. One is **connection lifecycle**: accept a socket, negotiate TLS, authenticate the client, find and authenticate to the upstream, and eventually tear everything down in the right order. The other is **protocol processing**: while the connection is up, move Postgres messages between the two ends, look inside a few of them, and decide what to do. The first job runs once per connection, in sequence. The second runs per message, in both directions, concurrently. They have different shapes, and code that mixes them tends to fork every time a new transport or feature arrives.
+
+The gateway from Post 1 mixed them, twice.
+
+## Before: one protocol, two implementations
+
+By 2025 the gateway served two client populations from one process: raw Postgres over TCP, and the HTTP and WebSocket API from Post 3. They had been built on separate timelines. Direct TCP access arrived in mid-2025 and reached general availability that October; the serverless API and its driver were developed alongside it from May 2025 and reached version 1.0 in November; the pooled hostname followed. Each path grew the code it needed when it needed it, and in mid-2026, when the team catalogued the codebase before redesigning it, the shape was clear.
+
+The TCP path implemented the protocol as two streaming pumps, one per direction, in under two hundred lines. Each pump read a five-byte message header, switched on the type byte, and either inspected the message (`ErrorResponse` was buffered and decoded, `BackendKeyData` was captured for cancellation, `ReadyForQuery` flipped a state flag) or streamed the body straight through. The serverless path implemented the same protocol as a pull iterator of nearly eight hundred lines plus a three-hundred-line flow-control state machine, because it had to unpack `RowDescription` and `DataRow` into API results and discard the bookkeeping messages the API client never sees. The catalog counted seven message types that the two implementations treated differently. `ParameterStatus` was forwarded on one path and dropped on the other. An unknown message type streamed through silently on TCP and raised an invariant error on the API. `ReadyForQuery` drove a state machine on TCP and was discarded on the API, which tracked state with a different three-state machine of its own.
+
+Lifecycle diverged the same way. TCP had a hardcoded handshake sequence and a close-cascade teardown; the API built its own startup, consumed backend messages until `ReadyForQuery` in its own loop, and cleaned up through a pool release plus a cancellation goroutine. Query cancellation, which requires a fresh connection carrying the backend's secret key, had one builder and two orchestrations: TCP ran cancels through a bounded worker pool guarded by the circuit breaker, the API spawned an unbounded goroutine per session with no breaker. And the wire-level library the codebase used for message bodies, `pgproto3` from the `pgx` project, had leaked into nineteen files, including the interface that resolved upstreams (its `Connect` took a `pgproto3.StartupMessage`) and the throttling code, which hand-built a `pgproto3.ErrorResponse` to reject a connection.
+
+None of this was a mystery to the people maintaining it. The reason it became urgent was pooling.
+
+## Pooling as the forcing function
+
+Post 2 described today's pooling arrangement: a per-tenant PgBouncer microVM that the gateway routes to. Integrating even that external pooler touched more than a dozen files in the gateway, split into separate development and production provisioners, and required a wrapper type just to get connection-reset behavior right. The team's next step, pooling inside the gateway process, would need something the two-implementation codebase could not offer cheaply: one place that sees every query-like message and every `ReadyForQuery`, on both transports, with the transaction status byte in hand. Transaction pooling is exactly the decision "can this backend be handed to another client now", and that decision needs a single, trustworthy view of the protocol.
+
+That is what turned a cleanup into a redesign. The written goals of the project, which the team calls PPg Proxy Revamped, put it as a common protocol-handling architecture onto which capabilities can be mounted as composable handlers, with streaming as a first-class property rather than a bypass, and with the wire vocabulary owned outright instead of borrowed. The catalog phase, pinned to a specific commit of the old proxy and citing files and line numbers for every claim, was done before any design was written, so that the design could be argued from evidence.
+
+## After: one pipeline, two edges
+
+The new codebase lives in a monorepo as a set of small Go modules, each with one job, assembled at a single composition root that is not allowed to contain business logic. The pieces that matter for this post:
+
+- **`pgwire`** owns the wire protocol. A `Frame` is a five-byte header plus a body, and a body has exactly one of three dispositions: **forward** it (write the header, stream the body, constant memory), **materialize** it into a capped buffer and decode a typed view (the only buffering path, bounded by a maximum size so a peer cannot drive allocation by lying about a length), or **construct** it from readers (how the API path forges `Parse`, `Bind`, and friends). There is no `pgproto3` dependency anywhere in the new tree, and a README rule keeps it that way.
+- **`pg-pipeline`** is the streaming phase: a double chain of responsibility, one chain per direction, over `pgwire` frames. The inbound chain (client to database) runs a throttle gate, then a query-state tracker, then the terminal that forwards. The outbound chain (database to client) runs an error tap, a backend-key tap, a `ReadyForQuery` tap, then the terminal. Each handler either calls the next one or does not, and the two chains never call each other; they share one small session object holding the connection's state and its cancel key.
+- **`pg-api-adapter`** is how the serverless API rides that pipeline. Rather than a second protocol implementation, it presents an API request as a **virtual Postgres client**: a frame source that forges the extended-query sequence from the request, and a frame sink that transcodes result messages into the client's response format. The pipeline does not know it is talking to anything but a Postgres client. A non-negotiable rule in that module is that it never materializes a body whose size the peer controls.
+- **`ppg-routing`** owns lifecycle: the listeners, and the once-through establishment chain (accept, TLS, credentials, resolution, upstream dial and SCRAM) that produces a connection and hands it to the pipeline. TCP and the API differ here by assembly, not by fork.
+- **`ppg-pool`** is the embedded transaction pool, discussed below.
+- Supporting modules own errors, logging, observability, throttling policy, upstream resolution against the configuration store, and usage metering, each behind a seam the pipeline emits events into rather than importing directly.
+
+```mermaid
+%% Before: two protocol implementations in one process. After: one pipeline, transport-specific
+%% code only at the client edge. Sources: ignite pg-protocol catalog (before);
+%% pdp-metal pg-pipeline, pg-api-adapter, ppg-routing READMEs (after).
+flowchart TB
+    subgraph before["Before: one protocol, two implementations"]
+        direction LR
+        b_tcp["TCP client"] --> b_pump["Streaming pumps<br/>(per-direction switch on message type)"] --> b_db1[("PostgreSQL")]
+        b_api["HTTP / WebSocket client"] --> b_iter["Pull iterator, flow-control<br/>state machine, bind sequence"] --> b_db2[("PostgreSQL")]
+    end
+
+    subgraph after["After: one pipeline, two client edges"]
+        direction LR
+        a_tcp["TCP client"] --> src_tcp["Source:<br/>socket reader"]
+        a_api["HTTP / WebSocket client"] --> src_api["Source: API adapter<br/>forges Parse, Bind, Execute"]
+        src_tcp --> chain["Shared pipeline (pgwire frames)<br/>inbound: throttle gate, query state, forward<br/>outbound: error tap, backend-key tap,<br/>ReadyForQuery tap, forward"]
+        src_api --> chain
+        chain --> conn["Connector: direct dial,<br/>or embedded transaction pool"] --> a_db[("PostgreSQL")]
+        chain --> term_tcp["Terminal:<br/>write to socket"] --> a_tcp
+        chain --> term_api["Terminal: transcode to<br/>NDJSON or WS frames"] --> a_api
+    end
+```
+
+_Before and after. Two separate protocol implementations become one pipeline whose only transport-specific parts are the inbound source and the outbound terminal at the client edge. Handler names are the ones used in the new codebase._
+
+The most important consequence is the one the diagram shows: the transport-specific code sits only at the client edge. On TCP, the inbound source is the client socket and the outbound terminal writes to it. On the API, the inbound source is the forging adapter and the outbound terminal is the transcoder. Everything between, the throttle gate, the query-state tracker, the error and key taps, and the metering events they emit, runs the same handler instances on both transports. A forged `Execute` and a native `Execute` are indistinguishable to the throttle gate, which closes a real gap: the old API path checked account holds once at connection time and never again, while TCP re-checked on every query. Now both paths run the same gate.
+
+Backpressure is a consequence of the same structure rather than a mechanism of its own. Each direction is one copy loop with no intermediate buffer, so a slow client blocks the transcoder, which stops reading the database socket. On the request side, the adapter handles one statement at a time and reads the next only when the current one has drained into the database, which replaces the unbounded pipelining queue that Post 3 flagged in the old API path. Every blocking operation carries a deadline, so a genuine stall tears the connection down rather than holding it forever.
+
+## Connection state, defined from the code
+
+The proposal for this series used the words "clean, busy, and dirty" for connection states. Those are not the terms the implementation uses, and it is worth being exact, because the real vocabulary explains how pooling works.
+
+The pipeline tracks each connection as **idle** or **active**: a query-like message from the client (`Query`, `Execute`, or the end of a `COPY`) makes it active, and a `ReadyForQuery` from the database makes it idle. That is enough for the gateway to know whether a cancel request is meaningful when a client disconnects mid-query.
+
+The pool needs more, because it has to know whether a backend can be reused, and that depends on transaction state. Postgres tells it: every `ReadyForQuery` carries a status byte, `I` for idle, `T` for inside a transaction block, `E` for inside a failed one. The pool's per-client session moves through named phases that follow from that byte. It starts **idle** with no backend attached. The first client frame moves it to **claiming**, where it asks the pool for a backend. Once lent, it is **serving**: the session keeps an account, raised by each client frame that demands a reply and lowered by each `ReadyForQuery`, so that a pipelined batch keeps the backend until the last reply. When the account settles and the status byte says `I`, the backend goes back to the pool as reusable and the session returns to idle. When the status byte says `T` or `E`, the backend cannot be shared, because it holds transaction state only this client can finish, so the session moves to **waiting**, the one phase where an idle-in-transaction timer is armed; if that timer fires, the session ends with the same error Postgres itself would use, and the backend is destroyed rather than reused. A **draining** phase handles a refused lend, and **ended** is terminal.
+
+Two details in that design are the kind of thing you only get right by owning the protocol. The `ReadyForQuery` that settles the account cannot simply be forwarded to the client, because by the time it would reach the client the backend has already been returned to the pool and the connection's frame reader has moved on; the session forges a byte-identical `ReadyForQuery` from the status it already decoded. And there is no repair path for a backend in an unknown state: if a session ends mid-request, the backend is destroyed, on the reasoning that guessing at session state is how pools leak one client's `SET` into another client's transaction. The pool's own documentation records that it chose destroy-only after comparing how two other open-source poolers handle the same question.
+
+## Testing became the proof
+
+The old codebase needed a Docker Compose stack, a real Postgres and a real configuration store, to run its default test suite, and it had no fuzz tests. The redesign treated a dependency-free harness as a requirement of the architecture rather than a nicety, and three pieces of it are verifiable in the new tree.
+
+A fake Postgres server, `fakepg`, built on `pgwire`, speaks the real wire protocol including SCRAM authentication with injectable randomness, so an authentication exchange is byte-for-byte deterministic. It runs in two modes. A router maps a SQL string to a canned result. A script is an ordered conversation, and this is the deterministic message sequence the proposal wanted to show, taken from the package's own documentation:
+
+```go
+fakepg.New(fakepg.WithBehavior(fakepg.Script{
+  fakepg.Expect(fakepg.Parse("", "SELECT 1")),
+  fakepg.Expect(fakepg.Tag(pgwire.TagBind)),
+  fakepg.Send(fakepg.ParseComplete()),
+  fakepg.Send(fakepg.BindComplete()),
+  fakepg.Send(fakepg.Rows(cols, rows)),
+  fakepg.Send(fakepg.ReadyForQuery()),
+}))
+```
+
+The server expects the client's `Parse` and `Bind`, then replies with completions, rows, and `ReadyForQuery`; any deviation is an error surfaced to the test. On top of that it ships fault behaviors named for what they exercise: a response that sends part of a message and hangs, one that drips bytes slowly, one that truncates mid-message, one that declares an oversized header, one that emits an error after partial results, and a slow reader that exercises write-side backpressure.
+
+Time is virtualized with Go's `testing/synctest`, so deadline and timeout logic runs against a fake clock, and goroutine coordination in tests uses a small runner primitive that turns an assertion failure inside a spawned goroutine into a test failure instead of a deadlock. Several of the new modules, including the API adapter and the pool, hold statement coverage at one hundred percent and enforce it in CI. An end-to-end suite runs the real gateway against real Postgres containers and the actual published `@prisma/ppg` driver as a subprocess, and a separate fuzz harness generates a whole scenario, sixteen databases and two hundred clients coming and going over a minute by default, across all four entry points, and judges the run by what the proxy reported.
+
+None of that is a performance claim, and this post makes none. What it establishes is that a protocol bug on either transport is now reproducible in a unit test with a scripted database, which was not true before.
+
+## What has landed, and what has not
+
+This is an architecture post about work in progress, so here is the status as of the repository history in mid-September 2026.
+
+**Implemented in the new codebase.** The wire library, the pipeline, the API adapter, the lifecycle and listeners for TCP, HTTP, and WebSocket, the rqlite-backed resolver, the throttling policy ported from the old gateway, usage metering, the test harness above, and the embedded transaction pool. Pooling is selected by the pooled hostname the client presents in its TLS handshake, as today, or by a second listening port, and the API transports are pooled by default with a protocol-level opt-out. Client TLS termination and cross-region peering between gateways over mutual TLS were added in August.
+
+**Deployed.** The new gateway is deployed to development regions. The repository holds no production rollout for it at the time of writing, and the written plan calls for a bounded side-by-side period in which the old implementation is frozen.
+
+**Not yet settled.** The embedded pool's README states that it is complete and tested and that its design decisions are not yet approved; the project's original scope deferred in-process pooling to a follow-up, and the pool was built ahead of that decision. Whether production pooled traffic moves from per-tenant PgBouncer to the embedded pool, and when, is a decision the team has not published.
+
+**Roadmap ideas from the proposal, not evidenced as plans.** The series proposal described pooling as a combination of "protocol sensing" and a "connection factory", with a rollout order of query detection, then transaction-boundary tracking, then unsupported-statement detection. The codebase's `ReadyForQuery` tracking is the transaction-boundary piece, and the pipeline docs describe a future handler that inspects `Query` text for pooling decisions. The rollout order and the detection of unsupported statements do not appear in the code or its design documents, so treat them as ideas.
+
+## Takeaway
+
+Connection lifecycle and protocol processing are separate problems, and the gateway got simpler, safer, and more testable when the code was organized to say so. Lifecycle became a once-through chain assembled per transport. Protocol processing became one pipeline that both transports feed, with the only transport-specific code at the client edge, so a policy written once applies to every connection. Owning the wire vocabulary made streaming the default and bounded materialization the exception, which is what let the serverless path stop buffering and what lets a pool read transaction state from the protocol rather than guessing. The costs are real: a rewrite, a migration that is still under way, and a set of design decisions that are documented but not yet all approved. The benefit that is already verifiable is that the two paths to a Prisma Postgres database now share one definition of what a Postgres message means.
diff --git a/apps/blog/content/blog/why-prisma-postgres-needs-a-gateway/index.mdx b/apps/blog/content/blog/why-prisma-postgres-needs-a-gateway/index.mdx
new file mode 100644
index 0000000000..789ea284ea
--- /dev/null
+++ b/apps/blog/content/blog/why-prisma-postgres-needs-a-gateway/index.mdx
@@ -0,0 +1,150 @@
+---
+title: "Why Prisma Postgres Needs a Gateway"
+slug: "why-prisma-postgres-needs-a-gateway"
+date: "2026-09-16"
+authors:
+  - "Ankur Datta"
+metaTitle: "Why Prisma Postgres Needs a Gateway"
+metaDescription: "Every connection to a Prisma Postgres database crosses one gateway service on the database host. What it authenticates, routes, meters, throttles, and observes, and why relaying bytes was never enough."
+excerpt: "The connectivity, security, and isolation problems a multi-tenant Postgres platform must solve, and the gateway that solves them."
+heroImagePath: "/why-prisma-postgres-needs-a-gateway/imgs/hero.svg"
+heroImageAlt: "Cover: three client tiles (a Postgres driver, a pooled client, a serverless function) flow into one highlighted gateway tile, which fans out across a dashed boundary to three isolated database icons, under the headline One gateway, every connection."
+metaImagePath: "/why-prisma-postgres-needs-a-gateway/imgs/meta.png"
+tags:
+  - "prisma-postgres"
+  - "education"
+  - "platform"
+series: prisma-postgres-connectivity
+seriesIndex: 1
+---
+
+_This is the first post in a four-part series on how Prisma Postgres handles database connectivity. The next installment covers connection pooling: [Why serverless apps are hard on Postgres connections](/why-serverless-apps-are-hard-on-postgres-connections)._
+
+After reading this post, you'll understand what sits between your application and a Prisma Postgres database, and why that component has to do far more than relay bytes.
+
+Start with the connection string. A [Prisma Postgres](https://www.prisma.io/docs/postgres) database gives you something that looks completely ordinary:
+
+```text
+postgres://<user>:<api-key>@db.prisma.io:5432/postgres?sslmode=require
+```
+
+`psql` accepts it. So do node-postgres, Drizzle, Kysely, DBeaver, and Prisma ORM. That ordinariness is the point of the product, and it hides a real question: where does that TCP connection actually go? There is no single Postgres server at `db.prisma.io`. There are bare-metal hosts in several regions, and each host runs a large number of isolated database instances, one per customer database, as unikernel microVMs. (Nikolas Burk described that hosting design when Prisma Postgres launched, in [Building a Modern PostgreSQL Service Using Unikernels and MicroVMs](https://www.prisma.io/blog/announcing-prisma-postgres-early-access), and followed it with [a walk through the life of a query](https://www.prisma.io/blog/cloudflare-unikernels-and-bare-metal-life-of-a-prisma-postgres-query). This series takes the hosting layer as given and stays on the connection path.) Your database is one of those VMs, on one of those hosts, in one region, and the hostname you connect to knows nothing about which one.
+
+Something has to close that gap on every connection. In Prisma Postgres that something is a gateway service the team calls the PPg TCP Proxy, and this post is about why it exists and what it is responsible for.
+
+## The naive design and where it breaks
+
+Suppose you tried to run a multi-tenant Postgres platform without a gateway. Each database VM listens on its own port, DNS points customers at their VM, and the database's own authentication handles access. This works for one host and a handful of databases. It stops working along four separate axes as soon as the platform is real.
+
+**Routing.** A database lives on one host, but the customer should reach it from anywhere. If DNS resolves to the host nearest the client, that host is often not the one holding the database. Someone has to know where the database is right now, and that knowledge changes when databases are created, restored, moved, or when a host is drained for maintenance.
+
+**Isolation.** Hundreds or thousands of customer databases share a host. Exposing each VM's Postgres port directly means every VM is a separate attack surface, every VM does its own TLS termination, and a misconfiguration on one VM is a public-facing mistake. The platform also loses the ability to reason about who is connecting to what.
+
+**Credentials.** The connection string above carries an API key, not the Postgres password of the underlying database. Keeping those two things separate is deliberate: a customer can create and revoke keys per environment without the database's own credentials ever leaving the platform. That separation needs a component that can accept one credential from the client and present another to the database.
+
+**Abuse and operations.** Postgres has a hard cap on concurrent connections, and one tenant's connection storm should not take down its neighbors on the same host. A rolling upgrade should not cut every session on a host at once. When something breaks, the operator needs to know whether the failure was the platform's fault or the client's. None of these concerns can be handled by the database process itself.
+
+Each of these problems can be solved in isolation. The interesting decision is where to solve them together.
+
+## The gateway as a deliberate boundary
+
+Prisma runs one gateway process on every database host. Every client-facing connection to a Prisma Postgres database enters through it, whether the client speaks the raw Postgres wire protocol over TCP, connects through the pooled hostname, or uses the serverless driver over HTTP or WebSockets. The three paths differ in what happens after the gateway accepts the connection, and later posts cover those differences. What they share is the boundary.
+
+For a direct TCP connection, the gateway's work on each new session looks like this:
+
+1. Accept the TCP connection and negotiate TLS. The client's `SSLRequest` is handled here, not by the database VM.
+2. Read the Postgres startup message and ask the client for its credentials. The password field carries the API key.
+3. Resolve the tenant. The gateway looks up the key's hash and the database's location and connection parameters from a configuration store that is replicated to every host.
+4. Open a connection to the database VM and authenticate to it with the platform-held credentials, using Postgres's own SCRAM-SHA-256 exchange. The client never sees those credentials.
+5. Tell the client it is authenticated, then stream bytes in both directions for the rest of the session, inspecting only a few message types along the way.
+
+A conceptual view of the pieces involved:
+
+```mermaid
+%% Conceptual view: every client path enters one gateway process on a database host.
+%% Sources: ignite docs/metal/technology/ppg/architecture.md, pgbouncer/connection-flow.md,
+%% connection-modes-comparison.md, rqlite.md; pdp-cloudflare ppg-proxy.ts (usage push).
+flowchart TB
+    subgraph clients["Clients"]
+        direction LR
+        tcp["Postgres client<br/>db.prisma.io:5432"]
+        pooled["Postgres client<br/>pooled.db.prisma.io"]
+        sls["Serverless function<br/>@prisma/ppg over HTTPS or WSS"]
+    end
+
+    dns["BunnyDNS: resolves to the<br/>lowest-latency host"]
+
+    subgraph host["Database host (bare metal)"]
+        direction TB
+        gw["PPg gateway (ppg-proxy)<br/>TLS, API-key check, tenant routing,<br/>throttling, metering, selective streaming"]
+        pgb["Tenant PgBouncer VM<br/>transaction mode, on demand"]
+        db[("Tenant database VM<br/>PostgreSQL in a unikernel microVM")]
+        rq[("rqlite node<br/>keys, encrypted connection strings,<br/>holds, pool config")]
+    end
+
+    cp["Control plane (Cloudflare Workers)<br/>API keys and holds; fallback validation;<br/>usage intake"]
+
+    tcp --> dns
+    pooled --> dns
+    sls --> dns
+    dns --> gw
+    gw -- "direct" --> db
+    gw -- "pooled" --> pgb --> db
+    gw -. "cached lookup" .-> rq
+    gw -. "fallback validation, usage reports" .-> cp
+    cp -. "replicates tenant config" .-> rq
+```
+
+_Conceptual view of the connection path. Every client path enters the gateway on a database host; the gateway resolves the tenant from a locally replicated configuration store and connects to the database VM directly or through the tenant's pooler. Not every service is shown._
+
+Two things about this layout matter for the rest of the series. First, the gateway and the database VM are on the same physical host in the common case, so the hop from gateway to database is local. The network cost a client pays is the round trip to the nearest gateway; when DNS lands a client on a host that does not hold its database, the gateway connects onward to the host that does. Second, the documented way to reach a database VM is through this ingress. Customers do not get host access, and the gateway's own administrative and metrics endpoints sit behind a separate, token-gated port that is not reachable directly from the internet. A gateway is what makes it possible to treat "the database is reachable only through a controlled path" as a design property rather than a hope.
+
+## What the gateway gives you
+
+It is tempting to describe a proxy by its mechanics. The more useful description is what each responsibility does for the person on either side of it.
+
+### Authentication without sharing database credentials
+
+The credential a client presents is a tenant identifier plus an API key. The gateway validates the key against a stored hash and, on success, authenticates to the database using credentials that are stored encrypted in the platform's configuration store and decrypted only inside the gateway. Environment-scoped keys can be added and revoked independently, and revoking one does not require touching the database's own role or password.
+
+There is a cost to this indirection, and it is worth being precise about it. The gateway caches lookup results for a short window so that a burst of connections from one tenant does not turn into a burst of lookups. A revoked key can therefore keep working for a bounded number of seconds until that cache entry expires. That is a conscious tradeoff between revocation latency and lookup load, not an accident.
+
+### Tenant routing that survives change
+
+Because the gateway resolves the database location on every new connection, databases can move without customers changing anything. The routing data lives in a small replicated SQLite cluster, [rqlite](https://rqlite.io/), with a node on every host, which means a gateway can answer "where is this database and how do I authenticate to it" with a local read most of the time. The section on hard parts below returns to what that costs.
+
+### Usage visibility and fair accounting
+
+Every connection through the gateway is metered: how many queries it executed, how many bytes went in and out, how long the handshake took, how long the session lived, and which errors occurred. That data feeds three things that are easy to conflate:
+
+- **Your usage.** Prisma Postgres bills on database operations and storage. The operation count comes from the gateway's per-connection query metering. Storage is measured inside the database VM, not at the gateway, and backups flow from the VM to object storage on a separate path that never touches the gateway.
+- **Fair resource accounting.** The same counters tell the platform which tenant is generating load on a host, which is what makes the throttling described below possible.
+- **Operational safety.** Error counts are classified at the gateway as either the client's problem (a bad password, a malformed startup message, a SQL error) or the platform's problem (an unreachable upstream, a protocol error mid-stream). Only the second kind counts against the service's availability objective.
+
+### Throttling that protects neighbors
+
+The gateway enforces limits in two phases. After authentication, each tenant gets a bounded number of concurrent connections on a host; exceeding it returns the standard Postgres "too many connections" error (`53300`) with a retry hint rather than a dropped socket. Before TLS, the gateway watches its own handshake latency and total connection count and, when the host is under stress, sheds a fraction of new connections outright. Between those two, per-tenant limits shrink when the host is degraded, and a tenant that keeps generating connection-limit errors is automatically slowed down further.
+
+Operators can also place holds on a tenant, full or partial, from the control plane, and on the TCP path the gateway re-checks them on every query rather than only at connect time. (The serverless path checked holds only at connect time until the redesign in Post 4, which closes that gap.) The distinction the team draws here is a useful one for anyone designing limits: throttling that enforces a plan limit is expected behavior, but throttling that fires because the platform itself is overloaded counts as an availability failure, because it means the platform should have had more capacity.
+
+### One place to observe
+
+Because every connection crosses the gateway, it is also where the service-level objectives are defined and measured: connection success rate, execution success rate, handshake latency, and the fraction of time the host spends outside its normal throttle mode, evaluated per region as well as fleet-wide. A gateway that only relayed bytes could report throughput. A gateway that understands the protocol can tell you that a session failed after the client had already started a transaction, which is the failure that actually hurts.
+
+## The parts that are hard
+
+Colocating these responsibilities is the easy decision. Three consequences of it are hard, and they shape the rest of this series.
+
+**Distributing the routing data.** The gateway needs the answer to "where is this database" on every host, within a bounded delay of any change, without adding a network round trip to every connection. The current answer is the replicated store plus short-lived per-host caches with request coalescing, so that a thousand simultaneous connections from one tenant produce one lookup rather than a thousand. Every cache is a tradeoff between freshness and load, and the revocation window above is one visible consequence.
+
+**The protocol is message-oriented, and the libraries want to buffer.** The [Postgres wire protocol](https://www.postgresql.org/docs/current/protocol-overview.html) is a stream of typed, length-prefixed messages. A gateway that needs to count queries, catch errors, and capture the key needed to cancel a running query has to look inside some messages. The common Go libraries read whole messages into memory before handing them over, which is fine for a small `ErrorResponse` and unacceptable for a multi-gigabyte `COPY`. Prisma's gateway therefore does its own framing: it reads the five-byte header, decides whether the message is one of the few it needs to inspect, and otherwise streams the body straight through without allocating. The proxy's own test suite includes a case that pushes a gigabyte of `COPY` data through the gateway and asserts that memory barely moves. Post 3 and Post 4 are largely about what it takes to keep that property while adding features.
+
+**Buffering and noisy neighbors.** Anything the gateway holds in memory on behalf of one connection is memory another tenant on the same host cannot use. Horizontal scaling hides this problem, since more instances mean each one holds less, but it does not remove it. The team has learned this from operating an earlier managed proxy: scaling a connection pool horizontally caused user-visible slowness, and the replacement they have designed scales vertically alongside each database VM instead. The safest buffer is the one you never allocate, which is why the streaming discipline above is treated as a constraint rather than an optimization.
+
+> **Sidebar: observability is load too.** A gateway that sees every connection is also a gateway that can emit a log line and a trace span for every connection, and at fleet scale that volume becomes a workload in its own right. Two documented facts from the proxy's own history make the point. Its logger writes through an asynchronous ring buffer that drops lines when the sink cannot keep up, and it counts what it dropped, because blocking the data path on log I/O would be worse. And one cleanup commit removed duplicate tracing spans that a stack of instrumentation wrappers had been emitting for the same logical operation, cutting several million spans a day. Neither is a heroic story. Both are the kind of thing a gateway forces you to get right.
+
+## Takeaway
+
+A multi-tenant database service needs a controlled connection boundary, and that boundary has to authenticate, route, meter, throttle, and observe every session, not just forward it. Putting those responsibilities in one process per host is a deliberate choice: it gives the platform one place to enforce policy and one place to measure, at the cost of making that process the component that must stream efficiently, cache carefully, and never become the bottleneck it exists to prevent.
+
+The gateway establishes the boundary. It does not, by itself, solve the problem that brings most people to a managed Postgres service in the first place: what happens when a burst of short-lived compute instances all want a connection at once. That is the subject of the next post.
diff --git a/apps/blog/content/blog/why-serverless-apps-are-hard-on-postgres-connections/index.mdx b/apps/blog/content/blog/why-serverless-apps-are-hard-on-postgres-connections/index.mdx
new file mode 100644
index 0000000000..b95ac24ea6
--- /dev/null
+++ b/apps/blog/content/blog/why-serverless-apps-are-hard-on-postgres-connections/index.mdx
@@ -0,0 +1,154 @@
+---
+title: "Why Serverless Apps Are Hard on Postgres Connections"
+slug: "why-serverless-apps-are-hard-on-postgres-connections"
+date: "2026-09-16"
+authors:
+  - "Ankur Datta"
+metaTitle: "Why Serverless Apps Are Hard on Postgres Connections"
+metaDescription: "Short-lived compute turns concurrency into open Postgres connections. How transaction pooling manages a finite set of backend connections in Prisma Postgres, what it costs, and what it cannot fix."
+excerpt: "Connection lifecycle pressure, and what pooling can and cannot fix."
+heroImagePath: "/why-serverless-apps-are-hard-on-postgres-connections/imgs/hero.svg"
+heroImageAlt: "Cover: a grid of twenty small circles representing client sessions funnels into a highlighted pooler tile labeled transaction mode, which fans out to three backend connection tiles, under the headline Many clients, few connections."
+metaImagePath: "/why-serverless-apps-are-hard-on-postgres-connections/imgs/meta.png"
+tags:
+  - "prisma-postgres"
+  - "education"
+  - "platform"
+series: prisma-postgres-connectivity
+seriesIndex: 2
+---
+
+_This is the second post in a four-part series on how Prisma Postgres handles database connectivity. The [first post](/why-prisma-postgres-needs-a-gateway) explained the gateway that every connection passes through. This one is about what happens on the other side of it when the clients are short-lived._
+
+After reading this post, you'll understand why bursts of short-lived compute put pressure on Postgres connections, and exactly which part of that problem connection pooling addresses.
+
+Here is the scenario. You deploy an API handler to a serverless platform. It opens a Postgres connection, runs two or three queries, and returns. The platform is generous with concurrency: a traffic spike of a few hundred simultaneous requests is handled by starting a few hundred instances of your handler. Each instance dutifully opens its own database connection. On a long-running server this would be one process with a pool of, say, ten connections serving all of that traffic. On the serverless platform it is a few hundred connection attempts arriving at once, most of them for a single query, and the database's answer to the ones past its limit is a hard error:
+
+```text
+FATAL: too many connections for role "app"
+```
+
+Nothing about the queries was expensive. The database was not CPU-bound. It was connection-bound, and that distinction is the whole subject of this post.
+
+## Why a Postgres connection is not a cheap thing
+
+Postgres uses a process-per-connection model: the postmaster forks a new backend process for every client session, and that backend holds the session's state for as long as the client stays connected. The [PostgreSQL documentation](https://www.postgresql.org/docs/current/connect-estab.html) describes this directly, and it explains three consequences that matter here.
+
+First, establishing a session costs more than a TCP handshake. The client and server exchange a startup message, negotiate authentication (SCRAM-SHA-256 by default on modern setups), and the server sets up a backend with its own memory. Over TLS, and across a network, that is several sequential round trips before the first query byte is processed.
+
+Second, every open session consumes server memory and a slot in a fixed table. The `max_connections` setting is chosen at server start, and the server sizes shared resources based on it, so it is not something a managed service can simply raise on demand. On Prisma Postgres the limit is set per plan, and the application role is allowed only a fraction of it, with the remainder reserved for migrations and platform operations. The [connection pooling documentation](https://www.prisma.io/docs/postgres/database/connection-pooling) lists the current per-plan numbers.
+
+Third, and least obvious: a connection that is open but idle is still a backend process. Serverless platforms keep instances warm between invocations precisely so the next request is fast, and a warm instance that opened a connection keeps holding it. Which brings us to the shape of the traffic.
+
+## What "short-lived compute" actually does to connections
+
+It is tempting to say that every serverless invocation starts a new process and opens a new connection. That is not what the major platforms do, and the real behavior is what makes the problem hard to reason about.
+
+On AWS Lambda, an execution environment is frozen after an invocation and thawed for the next one, so a database connection declared outside the handler is reused across warm invocations. AWS's own guidance is to check whether a connection exists before creating one. But Lambda provisions a separate execution environment for every concurrent request, and it terminates environments every few hours even for continuously invoked functions. Concurrency therefore maps almost directly to open connections, and a burst of two hundred concurrent requests is two hundred environments, each with its own connection, whether or not any single environment is reused later.
+
+Vercel's Fluid Compute changes the shape again: multiple concurrent invocations can share one function instance, so a pool declared in module scope can serve several requests at once, and Vercel documents a helper that closes idle connections before an instance suspends. Cloudflare Workers can open outbound TCP sockets with the `connect()` API, but a socket cannot be created in global scope and shared across requests, and Cloudflare's own recommendation for Postgres is to go through a pooling layer.
+
+The common thread is not "no reuse". It is that the application does not control the lifetime of the thing holding the connection. Instances come and go on the platform's schedule, concurrency fans out into instances rather than into threads, and idle instances hold idle connections you cannot see. A pool inside one instance helps that instance and does nothing across instances. The connection budget has to be managed somewhere the platform's scaling cannot outrun.
+
+## What pooling does, precisely
+
+A connection pooler is a process that sits between clients and the database, holds a fixed set of authenticated backend connections open, and lends them to client sessions. Clients see a Postgres server. The database sees a small, stable number of sessions. The pooler's job is to decide when a backend connection can be handed from one client to another, and that decision is the entire design space.
+
+[PgBouncer](https://www.pgbouncer.org/), the pooler Prisma Postgres uses today, offers three answers, which its [feature documentation](https://www.pgbouncer.org/features.html) defines as follows:
+
+| Mode | When a backend connection returns to the pool | What a client can rely on |
+| --- | --- | --- |
+| Session | When the client disconnects | Everything: `SET`, prepared statements, temp tables, `LISTEN`, advisory locks all persist for the session |
+| Transaction | When the current transaction ends | Only what lives inside a transaction. Session-level state is lost between transactions |
+| Statement | When each statement finishes | Single statements only. Multi-statement transactions are rejected |
+
+Session mode barely pools at all: it saves the backend setup cost when a client reconnects, but a thousand connected clients still need a thousand backends. Statement mode pools aggressively but breaks transactions, which rules it out for most applications. Transaction mode is the common choice because a transaction is the smallest unit that still lets an application reason about atomicity, and because most application sessions spend most of their time between transactions.
+
+Here is what reuse looks like in transaction mode with three clients and one backend connection:
+
+```mermaid
+sequenceDiagram
+%% Transaction-mode reuse: three client sessions share one backend connection.
+%% The reuse decision is driven by the ReadyForQuery status byte ('I' idle, 'T' in transaction).
+%% Sources: PgBouncer features.html (pool modes); PostgreSQL protocol-message-formats.html (ReadyForQuery).
+    participant A as Client A
+    participant B as Client B
+    participant C as Client C
+    participant P as PgBouncer (transaction mode)
+    participant S as Backend connection
+
+    A->>P: BEGIN
+    P->>S: BEGIN (backend lent to A)
+    S-->>P: ReadyForQuery (T)
+    P-->>A: ReadyForQuery (T)
+    B->>P: SELECT ... (autocommit)
+    Note over P: B waits: the only backend is lent to A
+    A->>P: UPDATE ...
+    P->>S: UPDATE ...
+    S-->>P: ReadyForQuery (T)
+    P-->>A: ReadyForQuery (T)
+    A->>P: COMMIT
+    P->>S: COMMIT
+    S-->>P: ReadyForQuery (I)
+    Note over P: status I: transaction closed,<br/>backend returns to the pool
+    P-->>A: ReadyForQuery (I)
+    P->>S: SELECT ... (backend lent to B)
+    S-->>P: rows, ReadyForQuery (I)
+    P-->>B: rows, ReadyForQuery (I)
+    C->>P: INSERT ... (autocommit)
+    P->>S: INSERT ... (backend lent to C)
+    S-->>P: ReadyForQuery (I)
+    P-->>C: ReadyForQuery (I)
+```
+
+_Transaction-mode reuse with three clients and one backend connection. The pooler hands the backend to the next client only after Postgres reports the transaction closed in the status byte of its ReadyForQuery message. Simplified: a real pool holds more than one backend._
+
+Client A holds the backend from `BEGIN` to `COMMIT`. The moment Postgres reports the transaction closed, the pooler can hand the same backend to client B's autocommit statement, and then to client C. Three application sessions, one backend, and none of them waited on connection setup to the database. The reason the pooler can do this safely is a detail of the wire protocol: after every query cycle Postgres sends a `ReadyForQuery` message whose status byte says whether the session is idle, inside a transaction, or inside a failed transaction. Transaction pooling is built on reading that one byte. Post 4 comes back to it.
+
+The cost of this arrangement is equally precise. Anything a client sets on the session outside a transaction lands on whichever backend it happened to be holding, and the next transaction may get a different one. That is why the Prisma Postgres documentation says session state such as `SET` commands, prepared statements, advisory locks, and temporary tables are lost after each transaction boundary on pooled connections, and directs workloads that need them to a direct connection. (PgBouncer can track protocol-level prepared statements across backends when configured to, but that does not change the general rule: assume nothing survives the transaction.)
+
+## How Prisma Postgres pools today
+
+On Prisma Postgres, pooling is opt-in by hostname. The direct connection string points at `db.prisma.io`; the pooled one points at `pooled.db.prisma.io`. Both arrive at the gateway from Post 1. For a pooled connection the gateway routes to a PgBouncer instance that belongs to that one tenant, running in transaction mode, in front of the tenant's database VM:
+
+```text
+Application → gateway → tenant's PgBouncer (transaction mode) → database VM
+```
+
+Two properties of that arrangement are worth knowing because they shape its behavior.
+
+**The pooler is per tenant and starts on demand.** Each PgBouncer runs as its own microVM on the same host as the database, provisioned the first time a pooled connection arrives and frozen after a few seconds of inactivity, the same scale-to-zero mechanism the database VMs use. That isolates one tenant's pool from another's, and it means the first pooled connection to an idle database pays a provisioning or wake cost that later ones do not. The pool's minimum size is zero for the same reason: a pool that eagerly reopens backends would keep waking its database.
+
+**The limits are plan-sized.** PgBouncer has two independent knobs: how many clients may connect to it and how many backend connections it may hold. Prisma sizes both per plan, and the backend pool is smaller than the database's `max_connections`, so the pooler can never itself exhaust the database. The documentation publishes the client-side limits per plan, the 10-minute cap on a pooled query, and the 60-minute idle timeout on pooled sessions.
+
+The gateway itself holds no pool. It opens a fresh connection to PgBouncer for each client session and streams. That is a deliberate scoping: the gateway's job in this arrangement is routing and policy, and PgBouncer's is reuse. It also has a consequence for latency, which the next section is about.
+
+## What pooling fixes, and what it does not
+
+It is worth stating the non-goals plainly, because "connection pooling" is often described as if it made queries faster.
+
+**Pooling does not change query execution time.** A pooled `SELECT` runs the same plan on the same backend as a direct one. If a query is slow inside Postgres, a pooler cannot help.
+
+**Pooling does not reduce the client's connection setup cost on this path.** Count the sequential round trips a client pays before its first query byte: one for TCP, one for TLS, and two for the Postgres startup and password exchange with the gateway. Those happen at the full client-to-gateway latency in both modes, because the gateway terminates the client's session either way. What changes is the leg behind the gateway: with PgBouncer warm and a backend idle in its pool, the pooler answers the startup without opening a new database session, whereas a direct connection performs a fresh handshake and SCRAM exchange with the database. That leg is local to the host, so the saving is real but small relative to the client-facing round trips. If your client is far from the nearest region, pooling will not make connection setup feel fast; it will make it stop failing.
+
+**Pooling adds a hop.** Every pooled query crosses one more process. On the same host that is a small cost, but it is not zero, and a workload with one long-lived, well-behaved connection gains nothing from it.
+
+**Pooling can add waiting.** When every backend in the pool is busy, the next transaction queues inside PgBouncer instead of failing. That is the intended behavior under a burst, and it is better than a connection error, but it means end-to-end request latency can rise under load even though each query executes just as fast as before. When you measure a pooled workload, separate the time a query spent executing in Postgres from the time the request spent waiting for a backend. The second number is the one pooling controls.
+
+**Pooling reshapes the connection limit rather than lifting it.** The database still has its `max_connections`. What pooling changes is how many application sessions can share it. The [documentation](https://www.prisma.io/docs/postgres/database/connection-pooling) makes the same point: pooling does not increase the database connection limit, it makes better use of it.
+
+> **Sidebar: when the platform fights the pooler.** Running PgBouncer inside a VM that freezes when idle produced a failure mode worth learning from. PgBouncer keeps its backend connections open across client sessions, and it uses the monotonic clock to decide when an idle backend is old enough to be checked or closed. A frozen VM's monotonic clock stops. Meanwhile, the host's ingress closed the frozen pooler's long-idle connections to the database after a couple of hours, and because the pooler was the side that had opened those connections, it was not woken to see them close. On the next thaw, PgBouncer's timers reported almost no time elapsed, it handed a dead backend to a client, and the client saw `server conn crashed?` (SQLSTATE `08P01`). The mitigation is PgBouncer's own health check with no delay: before reusing a backend, send the empty query string, which Postgres answers with `EmptyQueryResponse` without touching the planner or the statistics views. The platform vendor has said it will wake both ends of a closed connection in a future fix. Until then, the lesson is that a pooler's idea of "idle for a while" has to survive the platform's idea of "asleep".
+
+## Where Accelerate fits, and where it is going
+
+Readers who have used Prisma for a while know an older answer to this problem. Prisma's Data Proxy, introduced in [Early Access in 2021](https://www.prisma.io/blog/prisma-data-proxy-xb16ba0p21), ran the Prisma query engine and a connection pool on Prisma's side, so that a serverless function could reach the database without holding a Postgres connection of its own. It [became Accelerate in 2023](https://www.prisma.io/blog/announcing-accelerate-usrvpi6sfkv4), which added a global cache. Accelerate is a different design from the pooler described above: the client speaks Prisma's query protocol over HTTPS to an edge worker, which forwards to a query engine instance near the database, and that engine holds a small pool of persistent connections to the database. The pool lives in the engine, not in front of the database.
+
+That design has served a lot of traffic, and it taught the team things the next post relies on. It is also being wound down: Prisma's [documentation](https://www.prisma.io/docs/accelerate) states that hosted Accelerate connections will be retired on December 1, 2026, that Prisma Postgres includes connection pooling, and that query caching is not carried over. The two paths forward are the pooled TCP hostname above and the serverless driver that Post 3 covers.
+
+One more thing is in progress and belongs in the roadmap column rather than the current one. The gateway's redesign, which Post 4 describes, includes an embedded transaction pool inside the gateway process itself, so that the pooler is no longer a separate microVM. That code exists and is tested in the new codebase, but its design is still under review and it is not what serves production pooled traffic at the time of writing.
+
+## Takeaway
+
+A connection pooler manages access to a finite set of backend connections. That is the whole job, and it is a valuable one when the number of things wanting a connection is decided by a platform's scaling behavior rather than by you. To judge whether pooling helps a workload, separate two costs that get conflated: the cost of establishing and holding connections, which pooling addresses, and the time queries spend executing in Postgres, which it does not. If the first number dominates, pool. If the second does, look at the queries.
+
+Pooling assumes one thing throughout: that the client can open a Postgres connection at all. Some runtimes cannot, or can only do so awkwardly, and even where they can, a request-scoped function is a poor fit for a protocol designed around long-lived sessions. That is the transport problem, and the next post is about the API Prisma built to solve it.
diff --git a/apps/blog/proposals/ppg-proxy-series.md b/apps/blog/proposals/ppg-proxy-series.md
new file mode 100644
index 0000000000..b58e469660
--- /dev/null
+++ b/apps/blog/proposals/ppg-proxy-series.md
@@ -0,0 +1,143 @@
+# ppg-proxy blog series (proposal)
+
+A four-part series on how we manage Prisma Postgres connectivity: what the ppg-proxy is, the problems it solves, how it evolved, the challenges we hit, and the revamp we did as a result.
+
+## Series framing
+
+**Promise:** How Prisma Postgres builds a secure, serverless-friendly connectivity layer for Postgres, and the engineering behind it.
+
+**Audience:** senior backend and platform engineers, plus database/protocol-curious readers. We keep the depth. Every post opens on a user-visible problem before going low-level.
+
+**Goal / definition of success:** build technical trust in Prisma Postgres connectivity and show the engineering rigor behind it. Secondary: it doubles as a recruiting signal for infra engineers. The structure below serves that goal.
+
+**Repeated structure per post** (makes each post easier to write and to follow):
+
+1. The problem a developer or operator actually hits
+2. Why the obvious solution breaks down
+3. Prisma's approach
+4. Tradeoffs and lessons learned
+5. What this unlocks next
+
+Each post opens with a one-line "After reading, you'll understand X" and closes with a concrete takeaway, not just a "what's next".
+
+**War stories** (logging-to-stdout, noisy neighbor, protocol rewrites, fakepg) appear as sidebars that support the reader-facing point. They are not the spine.
+
+**Jargon** (ingress, framing, flow control, terminal adapters, clean/busy/dirty connections, transaction-boundary detection, pgproto3, sub-message streaming) is introduced progressively and defined at first use, not assumed.
+
+---
+
+# Post 1 - Why Prisma Postgres needs a gateway
+
+_Subtitle: the connectivity, security, and isolation problems a multi-tenant Postgres platform must solve._
+
+**After reading, you'll understand** what sits between your app and a Prisma Postgres database, and why "a thin proxy" is the wrong mental model.
+
+1. The problem: connecting to a database in a multi-tenant, multi-region platform
+    - What Prisma Postgres is and where it runs (brief; we covered microVMs/unikernels before)
+    - Why "just expose Postgres on a port" does not survive contact with multi-tenancy, isolation, credential rotation, and abuse
+2. The gateway mental model (establish this early, before internals)
+    - ppg-proxy as a single control point: routing and tenant isolation, auth boundary, metering point, observability boundary. State plainly that it is all of these, and why co-locating them is deliberate.
+    - Security first: the gateway lets us cordon the Postgres hosts off from public traffic entirely. That is a structural security and maintenance win, not a side effect.
+3. What the gateway gives you (framed as reader value)
+    - Auth: API-key based, rotation without touching database credentials
+    - Usage visibility and fair resource accounting (queries, ingress/egress, backup traffic), framed as fairness, abuse protection, and operational safety rather than vendor billing
+    - Unified throttling, observability, access logging
+4. The hard parts (short teaser for the rest of the series)
+    - Distributing the routing data: choices and tradeoffs
+    - The Postgres wire protocol is message-oriented, and the open-source library landscape is uneven
+    - Buffering and the noisy-neighbor problem: horizontal scaling hides it, it does not solve it
+    - Why we committed to end-to-end low-level streaming while still inspecting selected messages (error reporting, query counting)
+    - Sidebar: our logging-to-stdout adventure, a short war story on why observability at a gateway is harder than it looks
+
+**Key takeaway:** the gateway is what makes secure, isolated, meterable Postgres access possible. The rest of the series is how we make it fast and serverless-friendly.
+
+**What's next:** we still need a serverless-friendly entry point and per-tenant pooling.
+
+---
+
+# Post 2 - Why serverless apps are hard on Postgres connections
+
+_Subtitle: connection lifecycle pressure, and what pooling can and cannot fix._
+
+**After reading, you'll understand** why ephemeral compute breaks the Postgres connection model, and exactly which part of that problem pooling solves.
+
+1. The problem: ephemeral compute meets a stateful connection model (keep tight, tie every point to DB connectivity)
+    - Short-lived processes and connection storms
+    - Persistent connection and transaction model vs throwaway compute (Lambda-style) vs a long-lived VM/EC2
+    - Sometimes no native TCP/TLS client connectivity at all (foreshadow Post 3, do not resolve it here)
+2. Why the obvious fix (a fresh connection per invocation) breaks down
+    - Connection create/teardown cost on the database
+    - Approaches to bridge the gap: dedicated pooler, HTTP/WS wrapper, or pooler-as-a-service (Accelerate does both, with limits)
+3. Prisma's approach: pooling
+    - What pooling is and its actual goal: relieve connection lifecycle pressure on the database
+    - Pooling levels (statement, transaction, connection) and how each reuses connections (query boundaries, transaction detection)
+    - How Prisma Postgres does it today (per-db pgbouncer) and its limits alongside the ppg-proxy
+4. Tradeoffs and non-goals
+    - Pooling does not make queries faster, and can add latency
+    - It helps connection lifecycle, not query performance
+    - The cases where a pooler actively slows you down
+5. What this unlocks / what is still missing
+    - Pooling fixes lifecycle pressure, not transport. Not every environment can open a TCP/TLS socket.
+
+**Explicit boundary with Post 3:** Post 2 is about connection lifecycle pressure. Post 3 is about transport and protocol limitations. Keeping these separate stops the two posts from overlapping.
+
+**Key takeaway:** pooling is the right tool for connection lifecycle pressure and the wrong tool for most of what people expect it to fix.
+
+**What's next:** the transport problem, reaching Postgres where TCP/TLS is not available.
+
+---
+
+# Post 3 - Designing a streaming API for serverless Postgres
+
+_Subtitle: an HTTP/WS access path that keeps Postgres semantics without buffering everything._
+
+**After reading, you'll understand** why request/response HTTP breaks down for a database, and what a streaming-first serverless Postgres API looks like.
+
+1. The problem: no TCP/TLS, but you still need real Postgres semantics
+    - Where we left off in Post 2: the transport gap
+    - Industry approaches: a bare pg-protocol wrapper vs a bespoke HTTP/WS API, and their tradeoffs
+2. Why request/response breaks down (lead with the hook: streaming)
+    - The driver is the easy part; the API contract is the hard part
+    - Neon's serverless driver as a technical case study: a mechanics-first deep dive into its protocol (neutral, no editorializing)
+    - Lessons from operating query engines and managed proxies at scale (Data Proxy, Accelerate): the noisy-neighbor problem, and why buffering forces caps on query duration and body size. Framed as our own hard-won lessons, not as products being broken.
+3. Prisma's approach: streaming as a first-class citizen
+    - The end-to-end streaming chain: ingress, encode/decode, framing and flow control, database session and sub-message streaming
+    - What streaming-first unlocks: no artificial duration or body-size caps, predictable behavior under load
+4. The client side (kept, but contained to the API/driver contract)
+    - Streaming as first-class but optional on the client: CollectableIterator
+    - Free wins from the model: query batching and pipelining vs traditional request/response, and how it blends into the driver API
+5. What this unlocks next
+    - A driver for every language, with a JDBC sketch. Positioned as a forward-looking close, not a structural pillar.
+
+**Key takeaway:** streaming-first is what lets a serverless HTTP/WS path behave like a real Postgres connection instead of a capped RPC.
+
+**What's next:** two access paths (raw TCP and serverless) still run as separate stacks. That is the revamp.
+
+---
+
+# Post 4 - Unifying TCP and serverless connectivity
+
+_Subtitle: one protocol pipeline, two terminal adapters, and embedded pooling._
+
+**After reading, you'll understand** how we collapsed two parallel connectivity stacks into one streaming pipeline, and why that unlocks better pooling.
+
+**Lead with the conceptual takeaway:** connection lifecycle and protocol handling are separate problems. Everything else in this post follows from that one idea.
+
+1. Before: two stacks that grew apart
+    - The raw pg-protocol TCP proxy and the serverless HTTP/WS API evolved on separate timelines and EA/GA phases
+    - The cost: duplicated or missing building blocks, inconsistent lifecycle logic, harder pooling
+    - Pooling as the forcing function: pgbouncer was a good quick win, but embedding pooling properly needs one centralized protocol handler (clean/busy/dirty connection state, transaction tracking)
+2. The problem to solve: a boundary contract between lifecycle and protocol, without giving up the streaming promise
+3. After: a unified pipeline (the architecture)
+    - Step 1: one cohesive raw pg-protocol library with first-class streaming, replacing a mixed pgproto3 and bespoke utility set
+    - Step 2: the core pg-protocol pipeline
+    - Step 3: serverless API and TCP terminal adapters on top of the same pipeline
+    - Sidebar: fakepg, and why deterministic pre-baked message sequences make protocol bugs testable. A concrete example after the architecture is clear, not a detour before it.
+4. The payoff (explicit before/after benefit)
+    - Better pooling, easier testing, consistent streaming, less duplication, room for future features
+    - Lessons learned about re-architecting under fast-paced evolution (one honest line on tooling; not a structural pillar, since that framing ages badly)
+5. What's next
+    - Pooling as a two-facet system: protocol sensing plus connection factory
+    - The rollout plan: query detection first, then transaction-boundary tracking, then unsupported-statement detection last
+
+**Key takeaway:** separating lifecycle from protocol turned two fragile stacks into one testable, streaming pipeline that pooling can finally sit inside.
diff --git a/apps/blog/public/designing-a-streaming-api-for-serverless-postgres/imgs/hero.svg b/apps/blog/public/designing-a-streaming-api-for-serverless-postgres/imgs/hero.svg
new file mode 100644
index 0000000000..10cac33a60
--- /dev/null
+++ b/apps/blog/public/designing-a-streaming-api-for-serverless-postgres/imgs/hero.svg
@@ -0,0 +1,62 @@
+<svg width="1200" height="630" viewBox="0 0 1200 630" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <title>Designing a streaming API for serverless Postgres</title>
+  <desc>Data moving incrementally through a channel with controlled flow. Prisma blog cover, 2026 brand: light paper surface, spectral prism wash, Postgres yellow accent.</desc>
+  <defs>
+  <style>
+    @font-face{font-family:'Sora';font-style:normal;font-weight:100 800;src:url(data:font/woff2;base64,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) format('woff2');}
+    @font-face{font-family:'Inter';font-style:normal;font-weight:100 900;src:url(data:font/woff2;base64,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) format('woff2');}
+    @font-face{font-family:'Mona Sans Mono';font-style:normal;font-weight:200 900;src:url(data:font/woff2;base64,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) format('woff2');}
+  </style>
+    <radialGradient id="wash-yellow" cx="0.9" cy="1.1" r="0.75"><stop offset="0%" stop-color="#f3c306" stop-opacity="0.24"/><stop offset="100%" stop-color="#f3c306" stop-opacity="0"/></radialGradient>
+    <radialGradient id="wash-cyan" cx="0.1" cy="1.1" r="0.65"><stop offset="0%" stop-color="#01d7e4" stop-opacity="0.18"/><stop offset="100%" stop-color="#01d7e4" stop-opacity="0"/></radialGradient>
+    <filter id="grain"><feTurbulence type="fractalNoise" baseFrequency="0.9" numOctaves="2" stitchTiles="stitch"/><feColorMatrix type="saturate" values="0"/></filter>
+    <filter id="shadow" x="-10%" y="-10%" width="120%" height="130%"><feDropShadow dx="0" dy="10" stdDeviation="12" flood-color="#151515" flood-opacity="0.08"/></filter>
+    <marker id="arrow" markerWidth="8" markerHeight="8" refX="7" refY="4" orient="auto"><path d="M0,0 L8,4 L0,8 z" fill="#3a3b3c"/></marker>
+    <marker id="arrowacc" markerWidth="8" markerHeight="8" refX="7" refY="4" orient="auto"><path d="M0,0 L8,4 L0,8 z" fill="#eaa700"/></marker>
+  </defs>
+  <g id="background">
+    <rect width="1200" height="630" fill="#ffffff"/>
+    <rect width="1200" height="630" fill="url(#wash-yellow)"/>
+    <rect width="1200" height="630" fill="url(#wash-cyan)"/>
+    <rect width="1200" height="630" filter="url(#grain)" opacity="0.05" style="mix-blend-mode:multiply"/>
+  </g>
+  <g id="kicker"><circle cx="77" cy="95" r="5.5" fill="#f3c306"/><text x="92" y="101" font-family="Inter" font-weight="600" font-size="20" fill="rgba(21,21,21,0.70)">Prisma Postgres connectivity · Part 3</text></g>
+  <g id="headline"><text font-family="Sora" font-weight="500" font-size="62" fill="#151515" letter-spacing="-1"><tspan x="72" y="186">Stream rows,</tspan><tspan x="72" dy="72">not results</tspan></text></g>
+  <g id="module">
+<rect x="640" y="214" width="488" height="344" rx="20" fill="#ffffff" stroke="rgba(0,0,0,0.06)" stroke-width="1.5" filter="url(#shadow)"/>
+<rect x="664" y="354" width="96" height="64" rx="14" fill="#ffffff" stroke="rgba(0,0,0,0.06)" stroke-width="1.5"/><text x="712.0" y="391.0" text-anchor="middle" font-family="Mona Sans Mono" font-weight="500" font-size="15" fill="#151515">db</text>
+<rect x="1008" y="354" width="96" height="64" rx="14" fill="#ffffff" stroke="rgba(0,0,0,0.06)" stroke-width="1.5"/><text x="1056.0" y="391.0" text-anchor="middle" font-family="Mona Sans Mono" font-weight="500" font-size="15" fill="#151515">client</text>
+<rect x="776" y="366" width="216" height="40" rx="20" fill="#eef4f3"/>
+<rect x="796" y="378" width="26" height="16" rx="5" fill="#eaa700" opacity="1.0"/>
+<rect x="834" y="378" width="26" height="16" rx="5" fill="#eaa700" opacity="1.0"/>
+<rect x="872" y="378" width="26" height="16" rx="5" fill="#eaa700" opacity="1.0"/>
+<rect x="910" y="378" width="26" height="16" rx="5" fill="#eaa700" opacity="0.45"/>
+<rect x="948" y="378" width="26" height="16" rx="5" fill="#eaa700" opacity="0.45"/>
+<text x="884" y="344" text-anchor="middle" font-family="Mona Sans Mono" font-weight="500" font-size="12" fill="#646567">DataRow · one field at a time</text>
+<path d="M992,440 L784,440" stroke="#3a3b3c" stroke-width="1.5" stroke-dasharray="4 4" marker-end="url(#arrow)"/>
+<text x="884" y="466" text-anchor="middle" font-family="Inter" font-weight="400" font-size="13" fill="#646567">a slow client slows the sender</text>
+
+<circle cx="884" cy="296" r="22" fill="#ffffff" stroke="rgba(0,0,0,0.06)" stroke-width="1.5"/><path d="M884,296 L896,282" stroke="#eaa700" stroke-width="2.5" stroke-linecap="round"/><circle cx="884" cy="296" r="3" fill="#151515"/>
+<text x="884" y="256" text-anchor="middle" font-family="Mona Sans Mono" font-weight="500" font-size="12" fill="#646567">bounded memory</text>
+  </g>
+<g id="brand" transform="translate(72 528) scale(0.42)">
+<path d="M264 23.2767V52.6881H257.428V48.7257C256.351 50.1767 254.996 51.3115 253.362 52.13C251.728 52.9486 249.853 53.3578 247.737 53.3578C245.62 53.3578 243.671 52.9672 241.888 52.1858C240.143 51.4045 238.621 50.3441 237.321 49.0047C236.021 47.6281 235 46.0096 234.258 44.1493C233.552 42.2518 233.199 40.2055 233.199 38.0103C233.199 35.8152 233.552 33.806 234.258 31.9829C235 30.1226 236.021 28.5414 237.321 27.2392C238.621 25.8997 240.143 24.8766 241.888 24.1696C243.671 23.4255 245.62 23.0535 247.737 23.0535C249.853 23.0535 251.728 23.4441 253.362 24.2255C254.996 24.9696 256.351 26.0486 257.428 27.4624V23.2767H264ZM248.683 47.1072C249.946 47.1072 251.097 46.884 252.137 46.4375C253.176 45.991 254.067 45.3771 254.81 44.5958C255.59 43.7773 256.184 42.8099 256.592 41.6937C257.001 40.5775 257.205 39.3497 257.205 38.0103C257.205 35.2943 256.425 33.0991 254.866 31.4248C253.306 29.7506 251.245 28.9134 248.683 28.9134C247.458 28.9134 246.325 29.1367 245.286 29.5831C244.283 30.0296 243.411 30.6621 242.668 31.4806C241.925 32.2992 241.331 33.2665 240.886 34.3827C240.477 35.4989 240.273 36.7081 240.273 38.0103C240.273 39.3125 240.477 40.5217 240.886 41.6379C241.331 42.7541 241.925 43.7214 242.668 44.54C243.411 45.3213 244.283 45.9538 245.286 46.4375C246.325 46.884 247.458 47.1072 248.683 47.1072Z" fill="black"/>
+<path d="M217.188 22.6069C219.007 22.6069 220.622 22.9232 222.033 23.5557C223.444 24.151 224.614 24.9881 225.542 26.0671C226.508 27.1089 227.232 28.3553 227.715 29.8063C228.197 31.2201 228.439 32.7642 228.439 34.4385V52.6322H221.365V35.7221C221.365 33.8246 220.845 32.2247 219.806 30.9225C218.803 29.5831 217.299 28.9134 215.294 28.9134C214.291 28.9134 213.4 29.0994 212.621 29.4715C211.841 29.8435 211.172 30.3086 210.615 30.8667C210.096 31.4248 209.687 32.0573 209.39 32.7642C209.13 33.4711 209 34.1594 209 34.8291V52.6322H201.927V35.7221C201.927 33.7874 201.407 32.1689 200.367 30.8667C199.327 29.5645 197.805 28.9134 195.8 28.9134C194.797 28.9134 193.906 29.0994 193.126 29.4715C192.347 29.8435 191.697 30.3086 191.177 30.8667C190.657 31.4248 190.249 32.0573 189.952 32.7642C189.655 33.4339 189.506 34.1222 189.506 34.8291V52.6322H182.433V23.2766H189.116V26.5136C190.045 25.3974 191.251 24.4672 192.737 23.7231C194.222 22.979 195.967 22.6069 197.972 22.6069C200.311 22.6069 202.224 23.0162 203.709 23.8347C205.231 24.6533 206.42 25.8439 207.274 27.4065C208.09 26.0299 209.316 24.8951 210.95 24.0022C212.621 23.072 214.7 22.6069 217.188 22.6069Z" fill="black"/>
+<path d="M165.542 53.3578C162.349 53.3578 159.656 52.7253 157.466 51.4602C155.275 50.1952 153.771 48.3163 152.954 45.8235L159.137 43.4237C159.545 44.8004 160.306 45.8793 161.42 46.6607C162.571 47.4048 164.038 47.7768 165.82 47.7768C167.231 47.7768 168.345 47.4978 169.162 46.9397C170.016 46.3816 170.443 45.5817 170.443 44.5399C170.443 43.5726 170.035 42.8098 169.218 42.2517C168.438 41.6937 167.454 41.21 166.266 40.8007C165.078 40.3542 163.778 39.9264 162.367 39.5171C160.993 39.1078 159.712 38.5869 158.524 37.9544C157.336 37.2847 156.333 36.429 155.516 35.3872C154.737 34.3455 154.347 32.9874 154.347 31.3132C154.347 28.6343 155.368 26.5136 157.41 24.9509C159.452 23.3883 162.219 22.6069 165.709 22.6069C168.568 22.6069 170.963 23.165 172.894 24.2812C174.825 25.3974 176.106 26.96 176.737 28.9692L170.555 31.369C169.775 29.1738 168.122 28.0762 165.598 28.0762C164.298 28.0762 163.295 28.3367 162.59 28.8576C161.922 29.3784 161.587 30.0854 161.587 30.9783C161.587 31.8712 161.977 32.5782 162.757 33.099C163.574 33.5827 164.576 34.0106 165.765 34.3827C166.953 34.7175 168.234 35.0896 169.608 35.4988C171.019 35.8709 172.318 36.3918 173.507 37.0615C174.695 37.7312 175.679 38.6242 176.459 39.7403C177.275 40.8193 177.684 42.2517 177.684 44.0376C177.684 46.9769 176.57 49.2651 174.342 50.9022C172.151 52.5392 169.218 53.3578 165.542 53.3578Z" fill="black"/>
+<path d="M145.094 18.5886C143.72 18.5886 142.569 18.1608 141.641 17.305C140.713 16.4121 140.249 15.2773 140.249 13.9007C140.249 12.524 140.713 11.3892 141.641 10.4963C142.569 9.56615 143.72 9.10107 145.094 9.10107C146.468 9.10107 147.619 9.56615 148.548 10.4963C149.476 11.3892 149.94 12.524 149.94 13.9007C149.94 15.2773 149.476 16.4121 148.548 17.305C147.619 18.1608 146.468 18.5886 145.094 18.5886ZM141.53 23.2766H148.603V52.688H141.53V23.2766Z" fill="black"/>
+<path d="M128.687 26.5694C129.689 25.3788 130.933 24.43 132.418 23.7231C133.904 22.979 135.575 22.6069 137.431 22.6069V29.2482C134.869 29.2482 132.827 29.8621 131.304 31.0899C129.819 32.3177 129.077 33.9362 129.077 35.9453V52.6881H122.003V23.2766H128.687V26.5694Z" fill="black"/>
+<path d="M104.318 13.9006C106.36 13.9006 108.198 14.1797 109.832 14.7378C111.466 15.2959 112.858 16.0958 114.01 17.1376C115.161 18.1793 116.033 19.4443 116.627 20.9326C117.259 22.3836 117.574 24.0021 117.574 25.788C117.574 27.6111 117.259 29.2667 116.627 30.755C115.996 32.206 115.105 33.4524 113.954 34.4942C112.803 35.536 111.41 36.3359 109.776 36.894C108.143 37.4521 106.323 37.7311 104.318 37.7311H96.1306V52.688H89.0013V13.9006H104.318ZM103.984 31.4805C106.1 31.4805 107.679 30.9596 108.718 29.9179C109.795 28.8389 110.333 27.4623 110.333 25.788C110.333 24.1137 109.795 22.7557 108.718 21.7139C107.679 20.6721 106.1 20.1513 103.984 20.1513H96.1306V31.4805H103.984Z" fill="black"/>
+<g clip-path="url(#clip0_2_116)">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M14.5772 23.4756L0 38.0528V38.076L14.5772 23.4756Z" fill="#04D5E7"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M66.8662 28.8965V28.9405L39.7771 56.0295L66.8662 28.8965Z" fill="#FEBE29"/>
+<path d="M14.5772 23.4755L0 38.0527V13.5776L13.5284 0.0264573V0H38.0154L14.5772 23.4755Z" fill="#04D5E7"/>
+<path d="M66.866 23.2838L23.1498 67H0V43.7095L43.7095 0H66.866V23.2838Z" fill="#FE4352"/>
+<path d="M53.3113 67H28.8244L39.7771 56.0295L66.8662 28.9404V53.4224L53.3113 67Z" fill="#FEBE29"/>
+</g>
+<defs>
+<clipPath id="clip0_2_116">
+<rect width="66.866" height="67" fill="white"/>
+</clipPath>
+</defs>
+</g>
+</svg>
diff --git a/apps/blog/public/designing-a-streaming-api-for-serverless-postgres/imgs/meta.png b/apps/blog/public/designing-a-streaming-api-for-serverless-postgres/imgs/meta.png
new file mode 100644
index 0000000000..82e07835f2
Binary files /dev/null and b/apps/blog/public/designing-a-streaming-api-for-serverless-postgres/imgs/meta.png differ
diff --git a/apps/blog/public/unifying-tcp-and-serverless-connectivity-in-prisma-postgres/imgs/hero.svg b/apps/blog/public/unifying-tcp-and-serverless-connectivity-in-prisma-postgres/imgs/hero.svg
new file mode 100644
index 0000000000..f5e78f5418
--- /dev/null
+++ b/apps/blog/public/unifying-tcp-and-serverless-connectivity-in-prisma-postgres/imgs/hero.svg
@@ -0,0 +1,58 @@
+<svg width="1200" height="630" viewBox="0 0 1200 630" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <title>Unifying TCP and serverless connectivity in Prisma Postgres</title>
+  <desc>Two access paths meeting one shared protocol pipeline, with lifecycle handling kept apart. Prisma blog cover, 2026 brand: light paper surface, spectral prism wash, Postgres yellow accent.</desc>
+  <defs>
+  <style>
+    @font-face{font-family:'Sora';font-style:normal;font-weight:100 800;src:url(data:font/woff2;base64,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) format('woff2');}
+    @font-face{font-family:'Inter';font-style:normal;font-weight:100 900;src:url(data:font/woff2;base64,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) format('woff2');}
+    @font-face{font-family:'Mona Sans Mono';font-style:normal;font-weight:200 900;src:url(data:font/woff2;base64,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) format('woff2');}
+  </style>
+    <radialGradient id="wash-yellow" cx="0.85" cy="1.1" r="0.75"><stop offset="0%" stop-color="#f3c306" stop-opacity="0.24"/><stop offset="100%" stop-color="#f3c306" stop-opacity="0"/></radialGradient>
+    <radialGradient id="wash-cyan" cx="0.15" cy="1.1" r="0.65"><stop offset="0%" stop-color="#01d7e4" stop-opacity="0.18"/><stop offset="100%" stop-color="#01d7e4" stop-opacity="0"/></radialGradient>
+    <filter id="grain"><feTurbulence type="fractalNoise" baseFrequency="0.9" numOctaves="2" stitchTiles="stitch"/><feColorMatrix type="saturate" values="0"/></filter>
+    <filter id="shadow" x="-10%" y="-10%" width="120%" height="130%"><feDropShadow dx="0" dy="10" stdDeviation="12" flood-color="#151515" flood-opacity="0.08"/></filter>
+    <marker id="arrow" markerWidth="8" markerHeight="8" refX="7" refY="4" orient="auto"><path d="M0,0 L8,4 L0,8 z" fill="#3a3b3c"/></marker>
+    <marker id="arrowacc" markerWidth="8" markerHeight="8" refX="7" refY="4" orient="auto"><path d="M0,0 L8,4 L0,8 z" fill="#eaa700"/></marker>
+  </defs>
+  <g id="background">
+    <rect width="1200" height="630" fill="#ffffff"/>
+    <rect width="1200" height="630" fill="url(#wash-yellow)"/>
+    <rect width="1200" height="630" fill="url(#wash-cyan)"/>
+    <rect width="1200" height="630" filter="url(#grain)" opacity="0.05" style="mix-blend-mode:multiply"/>
+  </g>
+  <g id="kicker"><circle cx="77" cy="95" r="5.5" fill="#f3c306"/><text x="92" y="101" font-family="Inter" font-weight="600" font-size="20" fill="rgba(21,21,21,0.70)">Prisma Postgres connectivity · Part 4</text></g>
+  <g id="headline"><text font-family="Sora" font-weight="500" font-size="62" fill="#151515" letter-spacing="-1"><tspan x="72" y="186">Two paths,</tspan><tspan x="72" dy="72">one pipeline</tspan></text></g>
+  <g id="module">
+<rect x="640" y="214" width="488" height="344" rx="20" fill="#ffffff" stroke="rgba(0,0,0,0.06)" stroke-width="1.5" filter="url(#shadow)"/>
+<rect x="664" y="238" width="440" height="40" rx="12" fill="#eef4f3"/>
+<text x="884" y="263" text-anchor="middle" font-family="Mona Sans Mono" font-weight="500" font-size="13" fill="#3a3b3c">lifecycle: accept · tls · auth · resolve · teardown</text>
+<rect x="664" y="318" width="120" height="52" rx="14" fill="#ffffff" stroke="rgba(0,0,0,0.06)" stroke-width="1.5"/><text x="724.0" y="349.0" text-anchor="middle" font-family="Mona Sans Mono" font-weight="500" font-size="15" fill="#151515">tcp</text>
+<rect x="664" y="448" width="120" height="52" rx="14" fill="#ffffff" stroke="rgba(0,0,0,0.06)" stroke-width="1.5"/><text x="724.0" y="479.0" text-anchor="middle" font-family="Mona Sans Mono" font-weight="500" font-size="15" fill="#151515">http / ws</text>
+<path d="M784,344 C830,344 830,410 856,410" stroke="#3a3b3c" stroke-width="2" fill="none"/>
+<path d="M784,474 C830,474 830,410 856,410" stroke="#3a3b3c" stroke-width="2" fill="none"/>
+<rect x="858" y="366" width="150" height="88" rx="14" fill="#fcedc2" stroke="#eaa700" stroke-width="2"/><text x="933.0" y="406.0" text-anchor="middle" font-family="Mona Sans Mono" font-weight="500" font-size="15" fill="#151515">pipeline</text><text x="933.0" y="426.0" text-anchor="middle" font-family="Inter" font-weight="400" font-size="13" fill="#646567">shared handlers</text>
+<path d="M1008,410 L1046,410" stroke="#eaa700" stroke-width="2" marker-end="url(#arrowacc)"/>
+<rect x="1048" y="382" width="56" height="56" rx="14" fill="#ffffff" stroke="rgba(0,0,0,0.06)" stroke-width="1.5"/><ellipse cx="1076" cy="402" rx="16" ry="6" fill="none" stroke="#151515" stroke-width="1.5"/><path d="M1060,402 v14 a16,6 0 0 0 32,0 v-14" fill="none" stroke="#151515" stroke-width="1.5"/>
+<text x="884" y="520" text-anchor="middle" font-family="Mona Sans Mono" font-weight="500" font-size="12" fill="#646567">one protocol vocabulary</text>
+  </g>
+<g id="brand" transform="translate(72 528) scale(0.42)">
+<path d="M264 23.2767V52.6881H257.428V48.7257C256.351 50.1767 254.996 51.3115 253.362 52.13C251.728 52.9486 249.853 53.3578 247.737 53.3578C245.62 53.3578 243.671 52.9672 241.888 52.1858C240.143 51.4045 238.621 50.3441 237.321 49.0047C236.021 47.6281 235 46.0096 234.258 44.1493C233.552 42.2518 233.199 40.2055 233.199 38.0103C233.199 35.8152 233.552 33.806 234.258 31.9829C235 30.1226 236.021 28.5414 237.321 27.2392C238.621 25.8997 240.143 24.8766 241.888 24.1696C243.671 23.4255 245.62 23.0535 247.737 23.0535C249.853 23.0535 251.728 23.4441 253.362 24.2255C254.996 24.9696 256.351 26.0486 257.428 27.4624V23.2767H264ZM248.683 47.1072C249.946 47.1072 251.097 46.884 252.137 46.4375C253.176 45.991 254.067 45.3771 254.81 44.5958C255.59 43.7773 256.184 42.8099 256.592 41.6937C257.001 40.5775 257.205 39.3497 257.205 38.0103C257.205 35.2943 256.425 33.0991 254.866 31.4248C253.306 29.7506 251.245 28.9134 248.683 28.9134C247.458 28.9134 246.325 29.1367 245.286 29.5831C244.283 30.0296 243.411 30.6621 242.668 31.4806C241.925 32.2992 241.331 33.2665 240.886 34.3827C240.477 35.4989 240.273 36.7081 240.273 38.0103C240.273 39.3125 240.477 40.5217 240.886 41.6379C241.331 42.7541 241.925 43.7214 242.668 44.54C243.411 45.3213 244.283 45.9538 245.286 46.4375C246.325 46.884 247.458 47.1072 248.683 47.1072Z" fill="black"/>
+<path d="M217.188 22.6069C219.007 22.6069 220.622 22.9232 222.033 23.5557C223.444 24.151 224.614 24.9881 225.542 26.0671C226.508 27.1089 227.232 28.3553 227.715 29.8063C228.197 31.2201 228.439 32.7642 228.439 34.4385V52.6322H221.365V35.7221C221.365 33.8246 220.845 32.2247 219.806 30.9225C218.803 29.5831 217.299 28.9134 215.294 28.9134C214.291 28.9134 213.4 29.0994 212.621 29.4715C211.841 29.8435 211.172 30.3086 210.615 30.8667C210.096 31.4248 209.687 32.0573 209.39 32.7642C209.13 33.4711 209 34.1594 209 34.8291V52.6322H201.927V35.7221C201.927 33.7874 201.407 32.1689 200.367 30.8667C199.327 29.5645 197.805 28.9134 195.8 28.9134C194.797 28.9134 193.906 29.0994 193.126 29.4715C192.347 29.8435 191.697 30.3086 191.177 30.8667C190.657 31.4248 190.249 32.0573 189.952 32.7642C189.655 33.4339 189.506 34.1222 189.506 34.8291V52.6322H182.433V23.2766H189.116V26.5136C190.045 25.3974 191.251 24.4672 192.737 23.7231C194.222 22.979 195.967 22.6069 197.972 22.6069C200.311 22.6069 202.224 23.0162 203.709 23.8347C205.231 24.6533 206.42 25.8439 207.274 27.4065C208.09 26.0299 209.316 24.8951 210.95 24.0022C212.621 23.072 214.7 22.6069 217.188 22.6069Z" fill="black"/>
+<path d="M165.542 53.3578C162.349 53.3578 159.656 52.7253 157.466 51.4602C155.275 50.1952 153.771 48.3163 152.954 45.8235L159.137 43.4237C159.545 44.8004 160.306 45.8793 161.42 46.6607C162.571 47.4048 164.038 47.7768 165.82 47.7768C167.231 47.7768 168.345 47.4978 169.162 46.9397C170.016 46.3816 170.443 45.5817 170.443 44.5399C170.443 43.5726 170.035 42.8098 169.218 42.2517C168.438 41.6937 167.454 41.21 166.266 40.8007C165.078 40.3542 163.778 39.9264 162.367 39.5171C160.993 39.1078 159.712 38.5869 158.524 37.9544C157.336 37.2847 156.333 36.429 155.516 35.3872C154.737 34.3455 154.347 32.9874 154.347 31.3132C154.347 28.6343 155.368 26.5136 157.41 24.9509C159.452 23.3883 162.219 22.6069 165.709 22.6069C168.568 22.6069 170.963 23.165 172.894 24.2812C174.825 25.3974 176.106 26.96 176.737 28.9692L170.555 31.369C169.775 29.1738 168.122 28.0762 165.598 28.0762C164.298 28.0762 163.295 28.3367 162.59 28.8576C161.922 29.3784 161.587 30.0854 161.587 30.9783C161.587 31.8712 161.977 32.5782 162.757 33.099C163.574 33.5827 164.576 34.0106 165.765 34.3827C166.953 34.7175 168.234 35.0896 169.608 35.4988C171.019 35.8709 172.318 36.3918 173.507 37.0615C174.695 37.7312 175.679 38.6242 176.459 39.7403C177.275 40.8193 177.684 42.2517 177.684 44.0376C177.684 46.9769 176.57 49.2651 174.342 50.9022C172.151 52.5392 169.218 53.3578 165.542 53.3578Z" fill="black"/>
+<path d="M145.094 18.5886C143.72 18.5886 142.569 18.1608 141.641 17.305C140.713 16.4121 140.249 15.2773 140.249 13.9007C140.249 12.524 140.713 11.3892 141.641 10.4963C142.569 9.56615 143.72 9.10107 145.094 9.10107C146.468 9.10107 147.619 9.56615 148.548 10.4963C149.476 11.3892 149.94 12.524 149.94 13.9007C149.94 15.2773 149.476 16.4121 148.548 17.305C147.619 18.1608 146.468 18.5886 145.094 18.5886ZM141.53 23.2766H148.603V52.688H141.53V23.2766Z" fill="black"/>
+<path d="M128.687 26.5694C129.689 25.3788 130.933 24.43 132.418 23.7231C133.904 22.979 135.575 22.6069 137.431 22.6069V29.2482C134.869 29.2482 132.827 29.8621 131.304 31.0899C129.819 32.3177 129.077 33.9362 129.077 35.9453V52.6881H122.003V23.2766H128.687V26.5694Z" fill="black"/>
+<path d="M104.318 13.9006C106.36 13.9006 108.198 14.1797 109.832 14.7378C111.466 15.2959 112.858 16.0958 114.01 17.1376C115.161 18.1793 116.033 19.4443 116.627 20.9326C117.259 22.3836 117.574 24.0021 117.574 25.788C117.574 27.6111 117.259 29.2667 116.627 30.755C115.996 32.206 115.105 33.4524 113.954 34.4942C112.803 35.536 111.41 36.3359 109.776 36.894C108.143 37.4521 106.323 37.7311 104.318 37.7311H96.1306V52.688H89.0013V13.9006H104.318ZM103.984 31.4805C106.1 31.4805 107.679 30.9596 108.718 29.9179C109.795 28.8389 110.333 27.4623 110.333 25.788C110.333 24.1137 109.795 22.7557 108.718 21.7139C107.679 20.6721 106.1 20.1513 103.984 20.1513H96.1306V31.4805H103.984Z" fill="black"/>
+<g clip-path="url(#clip0_2_116)">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M14.5772 23.4756L0 38.0528V38.076L14.5772 23.4756Z" fill="#04D5E7"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M66.8662 28.8965V28.9405L39.7771 56.0295L66.8662 28.8965Z" fill="#FEBE29"/>
+<path d="M14.5772 23.4755L0 38.0527V13.5776L13.5284 0.0264573V0H38.0154L14.5772 23.4755Z" fill="#04D5E7"/>
+<path d="M66.866 23.2838L23.1498 67H0V43.7095L43.7095 0H66.866V23.2838Z" fill="#FE4352"/>
+<path d="M53.3113 67H28.8244L39.7771 56.0295L66.8662 28.9404V53.4224L53.3113 67Z" fill="#FEBE29"/>
+</g>
+<defs>
+<clipPath id="clip0_2_116">
+<rect width="66.866" height="67" fill="white"/>
+</clipPath>
+</defs>
+</g>
+</svg>
diff --git a/apps/blog/public/unifying-tcp-and-serverless-connectivity-in-prisma-postgres/imgs/meta.png b/apps/blog/public/unifying-tcp-and-serverless-connectivity-in-prisma-postgres/imgs/meta.png
new file mode 100644
index 0000000000..eb2851d91c
Binary files /dev/null and b/apps/blog/public/unifying-tcp-and-serverless-connectivity-in-prisma-postgres/imgs/meta.png differ
diff --git a/apps/blog/public/why-prisma-postgres-needs-a-gateway/imgs/hero.svg b/apps/blog/public/why-prisma-postgres-needs-a-gateway/imgs/hero.svg
new file mode 100644
index 0000000000..03e10b0959
--- /dev/null
+++ b/apps/blog/public/why-prisma-postgres-needs-a-gateway/imgs/hero.svg
@@ -0,0 +1,68 @@
+<svg width="1200" height="630" viewBox="0 0 1200 630" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <title>Why Prisma Postgres needs a gateway</title>
+  <desc>A controlled gateway boundary organising client access to isolated database destinations. Prisma blog cover, 2026 brand: light paper surface, spectral prism wash, Postgres yellow accent.</desc>
+  <defs>
+  <style>
+    @font-face{font-family:'Sora';font-style:normal;font-weight:100 800;src:url(data:font/woff2;base64,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) format('woff2');}
+    @font-face{font-family:'Inter';font-style:normal;font-weight:100 900;src:url(data:font/woff2;base64,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) format('woff2');}
+    @font-face{font-family:'Mona Sans Mono';font-style:normal;font-weight:200 900;src:url(data:font/woff2;base64,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) format('woff2');}
+  </style>
+    <radialGradient id="wash-yellow" cx="0.85" cy="1.1" r="0.75"><stop offset="0%" stop-color="#f3c306" stop-opacity="0.24"/><stop offset="100%" stop-color="#f3c306" stop-opacity="0"/></radialGradient>
+    <radialGradient id="wash-cyan" cx="0.15" cy="1.15" r="0.65"><stop offset="0%" stop-color="#01d7e4" stop-opacity="0.18"/><stop offset="100%" stop-color="#01d7e4" stop-opacity="0"/></radialGradient>
+    <filter id="grain"><feTurbulence type="fractalNoise" baseFrequency="0.9" numOctaves="2" stitchTiles="stitch"/><feColorMatrix type="saturate" values="0"/></filter>
+    <filter id="shadow" x="-10%" y="-10%" width="120%" height="130%"><feDropShadow dx="0" dy="10" stdDeviation="12" flood-color="#151515" flood-opacity="0.08"/></filter>
+    <marker id="arrow" markerWidth="8" markerHeight="8" refX="7" refY="4" orient="auto"><path d="M0,0 L8,4 L0,8 z" fill="#3a3b3c"/></marker>
+    <marker id="arrowacc" markerWidth="8" markerHeight="8" refX="7" refY="4" orient="auto"><path d="M0,0 L8,4 L0,8 z" fill="#eaa700"/></marker>
+  </defs>
+  <g id="background">
+    <rect width="1200" height="630" fill="#ffffff"/>
+    <rect width="1200" height="630" fill="url(#wash-yellow)"/>
+    <rect width="1200" height="630" fill="url(#wash-cyan)"/>
+    <rect width="1200" height="630" filter="url(#grain)" opacity="0.05" style="mix-blend-mode:multiply"/>
+  </g>
+  <g id="kicker"><circle cx="77" cy="95" r="5.5" fill="#f3c306"/><text x="92" y="101" font-family="Inter" font-weight="600" font-size="20" fill="rgba(21,21,21,0.70)">Prisma Postgres connectivity · Part 1</text></g>
+  <g id="headline"><text font-family="Sora" font-weight="500" font-size="62" fill="#151515" letter-spacing="-1"><tspan x="72" y="186">One gateway,</tspan><tspan x="72" dy="72">every connection</tspan></text></g>
+  <g id="module">
+<rect x="640" y="214" width="488" height="344" rx="20" fill="#ffffff" stroke="rgba(0,0,0,0.06)" stroke-width="1.5" filter="url(#shadow)"/>
+<rect x="664" y="250" width="150" height="56" rx="14" fill="#ffffff" stroke="rgba(0,0,0,0.06)" stroke-width="1.5"/><text x="739.0" y="283.0" text-anchor="middle" font-family="Mona Sans Mono" font-weight="500" font-size="15" fill="#151515">psql / pg driver</text>
+<path d="M814,278 L856,278" stroke="#3a3b3c" stroke-width="2" marker-end="url(#arrow)"/>
+<rect x="664" y="342" width="150" height="56" rx="14" fill="#ffffff" stroke="rgba(0,0,0,0.06)" stroke-width="1.5"/><text x="739.0" y="375.0" text-anchor="middle" font-family="Mona Sans Mono" font-weight="500" font-size="15" fill="#151515">pooled client</text>
+<path d="M814,370 L856,370" stroke="#3a3b3c" stroke-width="2" marker-end="url(#arrow)"/>
+<rect x="664" y="434" width="150" height="56" rx="14" fill="#ffffff" stroke="rgba(0,0,0,0.06)" stroke-width="1.5"/><text x="739.0" y="467.0" text-anchor="middle" font-family="Mona Sans Mono" font-weight="500" font-size="15" fill="#151515">serverless fn</text>
+<path d="M814,462 L856,462" stroke="#3a3b3c" stroke-width="2" marker-end="url(#arrow)"/>
+<rect x="858" y="250" width="120" height="240" rx="14" fill="#fcedc2" stroke="#eaa700" stroke-width="2"/><text x="918.0" y="375.0" text-anchor="middle" font-family="Mona Sans Mono" font-weight="500" font-size="15" fill="#151515">gateway</text>
+<text x="918" y="404" text-anchor="middle" font-family="Inter" font-weight="400" font-size="12" fill="#646567">auth · route</text>
+<text x="918" y="422" text-anchor="middle" font-family="Inter" font-weight="400" font-size="12" fill="#646567">meter · throttle</text>
+<line x1="1000" y1="236" x2="1000" y2="536" stroke="#eaa700" stroke-width="2" stroke-dasharray="6 6"/>
+<path d="M978,278 L1016,278" stroke="#eaa700" stroke-width="2" marker-end="url(#arrowacc)"/>
+<rect x="1018" y="250" width="86" height="56" rx="14" fill="#ffffff" stroke="rgba(0,0,0,0.06)" stroke-width="1.5"/>
+<ellipse cx="1061" cy="272" rx="20" ry="7" fill="none" stroke="#151515" stroke-width="1.5"/><path d="M1041,272 v14 a20,7 0 0 0 40,0 v-14" fill="none" stroke="#151515" stroke-width="1.5"/>
+<path d="M978,370 L1016,370" stroke="#eaa700" stroke-width="2" marker-end="url(#arrowacc)"/>
+<rect x="1018" y="342" width="86" height="56" rx="14" fill="#ffffff" stroke="rgba(0,0,0,0.06)" stroke-width="1.5"/>
+<ellipse cx="1061" cy="364" rx="20" ry="7" fill="none" stroke="#151515" stroke-width="1.5"/><path d="M1041,364 v14 a20,7 0 0 0 40,0 v-14" fill="none" stroke="#151515" stroke-width="1.5"/>
+<path d="M978,462 L1016,462" stroke="#eaa700" stroke-width="2" marker-end="url(#arrowacc)"/>
+<rect x="1018" y="434" width="86" height="56" rx="14" fill="#ffffff" stroke="rgba(0,0,0,0.06)" stroke-width="1.5"/>
+<ellipse cx="1061" cy="456" rx="20" ry="7" fill="none" stroke="#151515" stroke-width="1.5"/><path d="M1041,456 v14 a20,7 0 0 0 40,0 v-14" fill="none" stroke="#151515" stroke-width="1.5"/>
+<text x="1061" y="536" text-anchor="middle" font-family="Mona Sans Mono" font-weight="500" font-size="12" fill="#646567">isolated VMs</text>
+  </g>
+<g id="brand" transform="translate(72 528) scale(0.42)">
+<path d="M264 23.2767V52.6881H257.428V48.7257C256.351 50.1767 254.996 51.3115 253.362 52.13C251.728 52.9486 249.853 53.3578 247.737 53.3578C245.62 53.3578 243.671 52.9672 241.888 52.1858C240.143 51.4045 238.621 50.3441 237.321 49.0047C236.021 47.6281 235 46.0096 234.258 44.1493C233.552 42.2518 233.199 40.2055 233.199 38.0103C233.199 35.8152 233.552 33.806 234.258 31.9829C235 30.1226 236.021 28.5414 237.321 27.2392C238.621 25.8997 240.143 24.8766 241.888 24.1696C243.671 23.4255 245.62 23.0535 247.737 23.0535C249.853 23.0535 251.728 23.4441 253.362 24.2255C254.996 24.9696 256.351 26.0486 257.428 27.4624V23.2767H264ZM248.683 47.1072C249.946 47.1072 251.097 46.884 252.137 46.4375C253.176 45.991 254.067 45.3771 254.81 44.5958C255.59 43.7773 256.184 42.8099 256.592 41.6937C257.001 40.5775 257.205 39.3497 257.205 38.0103C257.205 35.2943 256.425 33.0991 254.866 31.4248C253.306 29.7506 251.245 28.9134 248.683 28.9134C247.458 28.9134 246.325 29.1367 245.286 29.5831C244.283 30.0296 243.411 30.6621 242.668 31.4806C241.925 32.2992 241.331 33.2665 240.886 34.3827C240.477 35.4989 240.273 36.7081 240.273 38.0103C240.273 39.3125 240.477 40.5217 240.886 41.6379C241.331 42.7541 241.925 43.7214 242.668 44.54C243.411 45.3213 244.283 45.9538 245.286 46.4375C246.325 46.884 247.458 47.1072 248.683 47.1072Z" fill="black"/>
+<path d="M217.188 22.6069C219.007 22.6069 220.622 22.9232 222.033 23.5557C223.444 24.151 224.614 24.9881 225.542 26.0671C226.508 27.1089 227.232 28.3553 227.715 29.8063C228.197 31.2201 228.439 32.7642 228.439 34.4385V52.6322H221.365V35.7221C221.365 33.8246 220.845 32.2247 219.806 30.9225C218.803 29.5831 217.299 28.9134 215.294 28.9134C214.291 28.9134 213.4 29.0994 212.621 29.4715C211.841 29.8435 211.172 30.3086 210.615 30.8667C210.096 31.4248 209.687 32.0573 209.39 32.7642C209.13 33.4711 209 34.1594 209 34.8291V52.6322H201.927V35.7221C201.927 33.7874 201.407 32.1689 200.367 30.8667C199.327 29.5645 197.805 28.9134 195.8 28.9134C194.797 28.9134 193.906 29.0994 193.126 29.4715C192.347 29.8435 191.697 30.3086 191.177 30.8667C190.657 31.4248 190.249 32.0573 189.952 32.7642C189.655 33.4339 189.506 34.1222 189.506 34.8291V52.6322H182.433V23.2766H189.116V26.5136C190.045 25.3974 191.251 24.4672 192.737 23.7231C194.222 22.979 195.967 22.6069 197.972 22.6069C200.311 22.6069 202.224 23.0162 203.709 23.8347C205.231 24.6533 206.42 25.8439 207.274 27.4065C208.09 26.0299 209.316 24.8951 210.95 24.0022C212.621 23.072 214.7 22.6069 217.188 22.6069Z" fill="black"/>
+<path d="M165.542 53.3578C162.349 53.3578 159.656 52.7253 157.466 51.4602C155.275 50.1952 153.771 48.3163 152.954 45.8235L159.137 43.4237C159.545 44.8004 160.306 45.8793 161.42 46.6607C162.571 47.4048 164.038 47.7768 165.82 47.7768C167.231 47.7768 168.345 47.4978 169.162 46.9397C170.016 46.3816 170.443 45.5817 170.443 44.5399C170.443 43.5726 170.035 42.8098 169.218 42.2517C168.438 41.6937 167.454 41.21 166.266 40.8007C165.078 40.3542 163.778 39.9264 162.367 39.5171C160.993 39.1078 159.712 38.5869 158.524 37.9544C157.336 37.2847 156.333 36.429 155.516 35.3872C154.737 34.3455 154.347 32.9874 154.347 31.3132C154.347 28.6343 155.368 26.5136 157.41 24.9509C159.452 23.3883 162.219 22.6069 165.709 22.6069C168.568 22.6069 170.963 23.165 172.894 24.2812C174.825 25.3974 176.106 26.96 176.737 28.9692L170.555 31.369C169.775 29.1738 168.122 28.0762 165.598 28.0762C164.298 28.0762 163.295 28.3367 162.59 28.8576C161.922 29.3784 161.587 30.0854 161.587 30.9783C161.587 31.8712 161.977 32.5782 162.757 33.099C163.574 33.5827 164.576 34.0106 165.765 34.3827C166.953 34.7175 168.234 35.0896 169.608 35.4988C171.019 35.8709 172.318 36.3918 173.507 37.0615C174.695 37.7312 175.679 38.6242 176.459 39.7403C177.275 40.8193 177.684 42.2517 177.684 44.0376C177.684 46.9769 176.57 49.2651 174.342 50.9022C172.151 52.5392 169.218 53.3578 165.542 53.3578Z" fill="black"/>
+<path d="M145.094 18.5886C143.72 18.5886 142.569 18.1608 141.641 17.305C140.713 16.4121 140.249 15.2773 140.249 13.9007C140.249 12.524 140.713 11.3892 141.641 10.4963C142.569 9.56615 143.72 9.10107 145.094 9.10107C146.468 9.10107 147.619 9.56615 148.548 10.4963C149.476 11.3892 149.94 12.524 149.94 13.9007C149.94 15.2773 149.476 16.4121 148.548 17.305C147.619 18.1608 146.468 18.5886 145.094 18.5886ZM141.53 23.2766H148.603V52.688H141.53V23.2766Z" fill="black"/>
+<path d="M128.687 26.5694C129.689 25.3788 130.933 24.43 132.418 23.7231C133.904 22.979 135.575 22.6069 137.431 22.6069V29.2482C134.869 29.2482 132.827 29.8621 131.304 31.0899C129.819 32.3177 129.077 33.9362 129.077 35.9453V52.6881H122.003V23.2766H128.687V26.5694Z" fill="black"/>
+<path d="M104.318 13.9006C106.36 13.9006 108.198 14.1797 109.832 14.7378C111.466 15.2959 112.858 16.0958 114.01 17.1376C115.161 18.1793 116.033 19.4443 116.627 20.9326C117.259 22.3836 117.574 24.0021 117.574 25.788C117.574 27.6111 117.259 29.2667 116.627 30.755C115.996 32.206 115.105 33.4524 113.954 34.4942C112.803 35.536 111.41 36.3359 109.776 36.894C108.143 37.4521 106.323 37.7311 104.318 37.7311H96.1306V52.688H89.0013V13.9006H104.318ZM103.984 31.4805C106.1 31.4805 107.679 30.9596 108.718 29.9179C109.795 28.8389 110.333 27.4623 110.333 25.788C110.333 24.1137 109.795 22.7557 108.718 21.7139C107.679 20.6721 106.1 20.1513 103.984 20.1513H96.1306V31.4805H103.984Z" fill="black"/>
+<g clip-path="url(#clip0_2_116)">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M14.5772 23.4756L0 38.0528V38.076L14.5772 23.4756Z" fill="#04D5E7"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M66.8662 28.8965V28.9405L39.7771 56.0295L66.8662 28.8965Z" fill="#FEBE29"/>
+<path d="M14.5772 23.4755L0 38.0527V13.5776L13.5284 0.0264573V0H38.0154L14.5772 23.4755Z" fill="#04D5E7"/>
+<path d="M66.866 23.2838L23.1498 67H0V43.7095L43.7095 0H66.866V23.2838Z" fill="#FE4352"/>
+<path d="M53.3113 67H28.8244L39.7771 56.0295L66.8662 28.9404V53.4224L53.3113 67Z" fill="#FEBE29"/>
+</g>
+<defs>
+<clipPath id="clip0_2_116">
+<rect width="66.866" height="67" fill="white"/>
+</clipPath>
+</defs>
+</g>
+</svg>
diff --git a/apps/blog/public/why-prisma-postgres-needs-a-gateway/imgs/meta.png b/apps/blog/public/why-prisma-postgres-needs-a-gateway/imgs/meta.png
new file mode 100644
index 0000000000..c2a4c8ed42
Binary files /dev/null and b/apps/blog/public/why-prisma-postgres-needs-a-gateway/imgs/meta.png differ
diff --git a/apps/blog/public/why-serverless-apps-are-hard-on-postgres-connections/imgs/hero.svg b/apps/blog/public/why-serverless-apps-are-hard-on-postgres-connections/imgs/hero.svg
new file mode 100644
index 0000000000..22f5ef5470
--- /dev/null
+++ b/apps/blog/public/why-serverless-apps-are-hard-on-postgres-connections/imgs/hero.svg
@@ -0,0 +1,78 @@
+<svg width="1200" height="630" viewBox="0 0 1200 630" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <title>Why serverless apps are hard on Postgres connections</title>
+  <desc>A burst of application connections reusing a smaller set of backend connections. Prisma blog cover, 2026 brand: light paper surface, spectral prism wash, Postgres yellow accent.</desc>
+  <defs>
+  <style>
+    @font-face{font-family:'Sora';font-style:normal;font-weight:100 800;src:url(data:font/woff2;base64,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) format('woff2');}
+    @font-face{font-family:'Inter';font-style:normal;font-weight:100 900;src:url(data:font/woff2;base64,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) format('woff2');}
+    @font-face{font-family:'Mona Sans Mono';font-style:normal;font-weight:200 900;src:url(data:font/woff2;base64,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) format('woff2');}
+  </style>
+    <radialGradient id="wash-yellow" cx="0.8" cy="1.1" r="0.75"><stop offset="0%" stop-color="#f3c306" stop-opacity="0.24"/><stop offset="100%" stop-color="#f3c306" stop-opacity="0"/></radialGradient>
+    <radialGradient id="wash-cyan" cx="0.2" cy="1.15" r="0.65"><stop offset="0%" stop-color="#01d7e4" stop-opacity="0.18"/><stop offset="100%" stop-color="#01d7e4" stop-opacity="0"/></radialGradient>
+    <filter id="grain"><feTurbulence type="fractalNoise" baseFrequency="0.9" numOctaves="2" stitchTiles="stitch"/><feColorMatrix type="saturate" values="0"/></filter>
+    <filter id="shadow" x="-10%" y="-10%" width="120%" height="130%"><feDropShadow dx="0" dy="10" stdDeviation="12" flood-color="#151515" flood-opacity="0.08"/></filter>
+    <marker id="arrow" markerWidth="8" markerHeight="8" refX="7" refY="4" orient="auto"><path d="M0,0 L8,4 L0,8 z" fill="#3a3b3c"/></marker>
+    <marker id="arrowacc" markerWidth="8" markerHeight="8" refX="7" refY="4" orient="auto"><path d="M0,0 L8,4 L0,8 z" fill="#eaa700"/></marker>
+  </defs>
+  <g id="background">
+    <rect width="1200" height="630" fill="#ffffff"/>
+    <rect width="1200" height="630" fill="url(#wash-yellow)"/>
+    <rect width="1200" height="630" fill="url(#wash-cyan)"/>
+    <rect width="1200" height="630" filter="url(#grain)" opacity="0.05" style="mix-blend-mode:multiply"/>
+  </g>
+  <g id="kicker"><circle cx="77" cy="95" r="5.5" fill="#f3c306"/><text x="92" y="101" font-family="Inter" font-weight="600" font-size="20" fill="rgba(21,21,21,0.70)">Prisma Postgres connectivity · Part 2</text></g>
+  <g id="headline"><text font-family="Sora" font-weight="500" font-size="62" fill="#151515" letter-spacing="-1"><tspan x="72" y="186">Many clients,</tspan><tspan x="72" dy="72">few connections</tspan></text></g>
+  <g id="module">
+<rect x="640" y="214" width="488" height="344" rx="20" fill="#ffffff" stroke="rgba(0,0,0,0.06)" stroke-width="1.5" filter="url(#shadow)"/>
+<circle cx="690" cy="262" r="8" fill="#ffffff" stroke="#3a3b3c" stroke-width="1.5"/>
+<circle cx="720" cy="262" r="8" fill="#ffffff" stroke="#3a3b3c" stroke-width="1.5"/>
+<circle cx="750" cy="262" r="8" fill="#ffffff" stroke="#3a3b3c" stroke-width="1.5"/>
+<circle cx="780" cy="262" r="8" fill="#ffffff" stroke="#3a3b3c" stroke-width="1.5"/>
+<circle cx="690" cy="308" r="8" fill="#ffffff" stroke="#3a3b3c" stroke-width="1.5"/>
+<circle cx="720" cy="308" r="8" fill="#ffffff" stroke="#3a3b3c" stroke-width="1.5"/>
+<circle cx="750" cy="308" r="8" fill="#ffffff" stroke="#3a3b3c" stroke-width="1.5"/>
+<circle cx="780" cy="308" r="8" fill="#ffffff" stroke="#3a3b3c" stroke-width="1.5"/>
+<circle cx="690" cy="354" r="8" fill="#ffffff" stroke="#3a3b3c" stroke-width="1.5"/>
+<circle cx="720" cy="354" r="8" fill="#ffffff" stroke="#3a3b3c" stroke-width="1.5"/>
+<circle cx="750" cy="354" r="8" fill="#ffffff" stroke="#3a3b3c" stroke-width="1.5"/>
+<circle cx="780" cy="354" r="8" fill="#ffffff" stroke="#3a3b3c" stroke-width="1.5"/>
+<circle cx="690" cy="400" r="8" fill="#ffffff" stroke="#3a3b3c" stroke-width="1.5"/>
+<circle cx="720" cy="400" r="8" fill="#ffffff" stroke="#3a3b3c" stroke-width="1.5"/>
+<circle cx="750" cy="400" r="8" fill="#ffffff" stroke="#3a3b3c" stroke-width="1.5"/>
+<circle cx="780" cy="400" r="8" fill="#ffffff" stroke="#3a3b3c" stroke-width="1.5"/>
+<circle cx="690" cy="446" r="8" fill="#ffffff" stroke="#3a3b3c" stroke-width="1.5"/>
+<circle cx="720" cy="446" r="8" fill="#ffffff" stroke="#3a3b3c" stroke-width="1.5"/>
+<circle cx="750" cy="446" r="8" fill="#ffffff" stroke="#3a3b3c" stroke-width="1.5"/>
+<circle cx="780" cy="446" r="8" fill="#ffffff" stroke="#3a3b3c" stroke-width="1.5"/>
+<text x="735" y="530" text-anchor="middle" font-family="Mona Sans Mono" font-weight="500" font-size="12" fill="#646567">20 client sessions</text>
+<path d="M812,262 L868,352 M812,354 L868,384 M812,446 L868,416" stroke="#3a3b3c" stroke-width="1.5" fill="none"/>
+<rect x="870" y="340" width="120" height="88" rx="14" fill="#fcedc2" stroke="#eaa700" stroke-width="2"/><text x="930.0" y="380.0" text-anchor="middle" font-family="Mona Sans Mono" font-weight="500" font-size="15" fill="#151515">pooler</text><text x="930.0" y="400.0" text-anchor="middle" font-family="Inter" font-weight="400" font-size="13" fill="#646567">transaction mode</text>
+<path d="M990,384 L1024,324" stroke="#eaa700" stroke-width="2" marker-end="url(#arrowacc)"/>
+<rect x="1026" y="302" width="78" height="44" rx="14" fill="#ffffff" stroke="rgba(0,0,0,0.06)" stroke-width="1.5"/><text x="1065.0" y="329.0" text-anchor="middle" font-family="Mona Sans Mono" font-weight="500" font-size="15" fill="#151515">conn</text>
+<path d="M990,384 L1024,384" stroke="#eaa700" stroke-width="2" marker-end="url(#arrowacc)"/>
+<rect x="1026" y="362" width="78" height="44" rx="14" fill="#ffffff" stroke="rgba(0,0,0,0.06)" stroke-width="1.5"/><text x="1065.0" y="389.0" text-anchor="middle" font-family="Mona Sans Mono" font-weight="500" font-size="15" fill="#151515">conn</text>
+<path d="M990,384 L1024,444" stroke="#eaa700" stroke-width="2" marker-end="url(#arrowacc)"/>
+<rect x="1026" y="422" width="78" height="44" rx="14" fill="#ffffff" stroke="rgba(0,0,0,0.06)" stroke-width="1.5"/><text x="1065.0" y="449.0" text-anchor="middle" font-family="Mona Sans Mono" font-weight="500" font-size="15" fill="#151515">conn</text>
+<text x="1065" y="530" text-anchor="middle" font-family="Mona Sans Mono" font-weight="500" font-size="12" fill="#646567">3 backends</text>
+  </g>
+<g id="brand" transform="translate(72 528) scale(0.42)">
+<path d="M264 23.2767V52.6881H257.428V48.7257C256.351 50.1767 254.996 51.3115 253.362 52.13C251.728 52.9486 249.853 53.3578 247.737 53.3578C245.62 53.3578 243.671 52.9672 241.888 52.1858C240.143 51.4045 238.621 50.3441 237.321 49.0047C236.021 47.6281 235 46.0096 234.258 44.1493C233.552 42.2518 233.199 40.2055 233.199 38.0103C233.199 35.8152 233.552 33.806 234.258 31.9829C235 30.1226 236.021 28.5414 237.321 27.2392C238.621 25.8997 240.143 24.8766 241.888 24.1696C243.671 23.4255 245.62 23.0535 247.737 23.0535C249.853 23.0535 251.728 23.4441 253.362 24.2255C254.996 24.9696 256.351 26.0486 257.428 27.4624V23.2767H264ZM248.683 47.1072C249.946 47.1072 251.097 46.884 252.137 46.4375C253.176 45.991 254.067 45.3771 254.81 44.5958C255.59 43.7773 256.184 42.8099 256.592 41.6937C257.001 40.5775 257.205 39.3497 257.205 38.0103C257.205 35.2943 256.425 33.0991 254.866 31.4248C253.306 29.7506 251.245 28.9134 248.683 28.9134C247.458 28.9134 246.325 29.1367 245.286 29.5831C244.283 30.0296 243.411 30.6621 242.668 31.4806C241.925 32.2992 241.331 33.2665 240.886 34.3827C240.477 35.4989 240.273 36.7081 240.273 38.0103C240.273 39.3125 240.477 40.5217 240.886 41.6379C241.331 42.7541 241.925 43.7214 242.668 44.54C243.411 45.3213 244.283 45.9538 245.286 46.4375C246.325 46.884 247.458 47.1072 248.683 47.1072Z" fill="black"/>
+<path d="M217.188 22.6069C219.007 22.6069 220.622 22.9232 222.033 23.5557C223.444 24.151 224.614 24.9881 225.542 26.0671C226.508 27.1089 227.232 28.3553 227.715 29.8063C228.197 31.2201 228.439 32.7642 228.439 34.4385V52.6322H221.365V35.7221C221.365 33.8246 220.845 32.2247 219.806 30.9225C218.803 29.5831 217.299 28.9134 215.294 28.9134C214.291 28.9134 213.4 29.0994 212.621 29.4715C211.841 29.8435 211.172 30.3086 210.615 30.8667C210.096 31.4248 209.687 32.0573 209.39 32.7642C209.13 33.4711 209 34.1594 209 34.8291V52.6322H201.927V35.7221C201.927 33.7874 201.407 32.1689 200.367 30.8667C199.327 29.5645 197.805 28.9134 195.8 28.9134C194.797 28.9134 193.906 29.0994 193.126 29.4715C192.347 29.8435 191.697 30.3086 191.177 30.8667C190.657 31.4248 190.249 32.0573 189.952 32.7642C189.655 33.4339 189.506 34.1222 189.506 34.8291V52.6322H182.433V23.2766H189.116V26.5136C190.045 25.3974 191.251 24.4672 192.737 23.7231C194.222 22.979 195.967 22.6069 197.972 22.6069C200.311 22.6069 202.224 23.0162 203.709 23.8347C205.231 24.6533 206.42 25.8439 207.274 27.4065C208.09 26.0299 209.316 24.8951 210.95 24.0022C212.621 23.072 214.7 22.6069 217.188 22.6069Z" fill="black"/>
+<path d="M165.542 53.3578C162.349 53.3578 159.656 52.7253 157.466 51.4602C155.275 50.1952 153.771 48.3163 152.954 45.8235L159.137 43.4237C159.545 44.8004 160.306 45.8793 161.42 46.6607C162.571 47.4048 164.038 47.7768 165.82 47.7768C167.231 47.7768 168.345 47.4978 169.162 46.9397C170.016 46.3816 170.443 45.5817 170.443 44.5399C170.443 43.5726 170.035 42.8098 169.218 42.2517C168.438 41.6937 167.454 41.21 166.266 40.8007C165.078 40.3542 163.778 39.9264 162.367 39.5171C160.993 39.1078 159.712 38.5869 158.524 37.9544C157.336 37.2847 156.333 36.429 155.516 35.3872C154.737 34.3455 154.347 32.9874 154.347 31.3132C154.347 28.6343 155.368 26.5136 157.41 24.9509C159.452 23.3883 162.219 22.6069 165.709 22.6069C168.568 22.6069 170.963 23.165 172.894 24.2812C174.825 25.3974 176.106 26.96 176.737 28.9692L170.555 31.369C169.775 29.1738 168.122 28.0762 165.598 28.0762C164.298 28.0762 163.295 28.3367 162.59 28.8576C161.922 29.3784 161.587 30.0854 161.587 30.9783C161.587 31.8712 161.977 32.5782 162.757 33.099C163.574 33.5827 164.576 34.0106 165.765 34.3827C166.953 34.7175 168.234 35.0896 169.608 35.4988C171.019 35.8709 172.318 36.3918 173.507 37.0615C174.695 37.7312 175.679 38.6242 176.459 39.7403C177.275 40.8193 177.684 42.2517 177.684 44.0376C177.684 46.9769 176.57 49.2651 174.342 50.9022C172.151 52.5392 169.218 53.3578 165.542 53.3578Z" fill="black"/>
+<path d="M145.094 18.5886C143.72 18.5886 142.569 18.1608 141.641 17.305C140.713 16.4121 140.249 15.2773 140.249 13.9007C140.249 12.524 140.713 11.3892 141.641 10.4963C142.569 9.56615 143.72 9.10107 145.094 9.10107C146.468 9.10107 147.619 9.56615 148.548 10.4963C149.476 11.3892 149.94 12.524 149.94 13.9007C149.94 15.2773 149.476 16.4121 148.548 17.305C147.619 18.1608 146.468 18.5886 145.094 18.5886ZM141.53 23.2766H148.603V52.688H141.53V23.2766Z" fill="black"/>
+<path d="M128.687 26.5694C129.689 25.3788 130.933 24.43 132.418 23.7231C133.904 22.979 135.575 22.6069 137.431 22.6069V29.2482C134.869 29.2482 132.827 29.8621 131.304 31.0899C129.819 32.3177 129.077 33.9362 129.077 35.9453V52.6881H122.003V23.2766H128.687V26.5694Z" fill="black"/>
+<path d="M104.318 13.9006C106.36 13.9006 108.198 14.1797 109.832 14.7378C111.466 15.2959 112.858 16.0958 114.01 17.1376C115.161 18.1793 116.033 19.4443 116.627 20.9326C117.259 22.3836 117.574 24.0021 117.574 25.788C117.574 27.6111 117.259 29.2667 116.627 30.755C115.996 32.206 115.105 33.4524 113.954 34.4942C112.803 35.536 111.41 36.3359 109.776 36.894C108.143 37.4521 106.323 37.7311 104.318 37.7311H96.1306V52.688H89.0013V13.9006H104.318ZM103.984 31.4805C106.1 31.4805 107.679 30.9596 108.718 29.9179C109.795 28.8389 110.333 27.4623 110.333 25.788C110.333 24.1137 109.795 22.7557 108.718 21.7139C107.679 20.6721 106.1 20.1513 103.984 20.1513H96.1306V31.4805H103.984Z" fill="black"/>
+<g clip-path="url(#clip0_2_116)">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M14.5772 23.4756L0 38.0528V38.076L14.5772 23.4756Z" fill="#04D5E7"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M66.8662 28.8965V28.9405L39.7771 56.0295L66.8662 28.8965Z" fill="#FEBE29"/>
+<path d="M14.5772 23.4755L0 38.0527V13.5776L13.5284 0.0264573V0H38.0154L14.5772 23.4755Z" fill="#04D5E7"/>
+<path d="M66.866 23.2838L23.1498 67H0V43.7095L43.7095 0H66.866V23.2838Z" fill="#FE4352"/>
+<path d="M53.3113 67H28.8244L39.7771 56.0295L66.8662 28.9404V53.4224L53.3113 67Z" fill="#FEBE29"/>
+</g>
+<defs>
+<clipPath id="clip0_2_116">
+<rect width="66.866" height="67" fill="white"/>
+</clipPath>
+</defs>
+</g>
+</svg>
diff --git a/apps/blog/public/why-serverless-apps-are-hard-on-postgres-connections/imgs/meta.png b/apps/blog/public/why-serverless-apps-are-hard-on-postgres-connections/imgs/meta.png
new file mode 100644
index 0000000000..ee1791abc8
Binary files /dev/null and b/apps/blog/public/why-serverless-apps-are-hard-on-postgres-connections/imgs/meta.png differ
diff --git a/apps/blog/src/lib/series-registry.ts b/apps/blog/src/lib/series-registry.ts
index 5c6c694fe3..e2381b7225 100644
--- a/apps/blog/src/lib/series-registry.ts
+++ b/apps/blog/src/lib/series-registry.ts
@@ -34,6 +34,15 @@ export const seriesRegistry = {
     featured: true,
     relatedSeries: ["agentic-engineering", "prisma-compute"],
   },
+  "prisma-postgres-connectivity": {
+    title: "Inside Prisma Postgres connectivity",
+    description:
+      "How Prisma Postgres manages secure, serverless-friendly database connectivity: the gateway every connection crosses, connection pooling, the streaming serverless API, and the shared protocol pipeline behind both paths.",
+    featured: false,
+    docsUrl: "https://www.prisma.io/docs/postgres",
+    docsLabel: "Read the Prisma Postgres docs",
+    relatedSeries: ["prisma-compute", "prisma-8"],
+  },
   "rust-to-typescript-migration-journey": {
     title: "Prisma ORM: The Complete Rust-to-TypeScript Migration Journey",
     description: