300ms to 60ms: How I Slashed API Latency by 80% with One Config Change

Kabeer N Shah — Sun, 25 Jan 2026 17:09:14 +0000

When migrating an application from a serverless environment to a dedicated cloud VPS, you expect a performance boost. After all, you're moving from transient functions to a persistent server.

But when I finished my migration recently, my health checks told a different story.

Despite my application server and managed database being hosted in neighboring regions, the database latency was consistently hovering around 300ms - 350ms. For a simple SELECT 1 query, that is an eternity.

Here is how I diagnosed the "Serverless Hangover" and reclaimed 80% of my performance.

The Investigation

Physics told me the connection should be fast. A standard network ping between the two servers showed a round-trip time of about 60ms.

So, why was my application reporting 350ms?

I looked at the usual suspects:

Resource Constraints: CPU and RAM usage were minimal.
Application Logic: The health check endpoint was as lean as possible.
Network Congestion: Consistent results across different times of day ruled this out.

The culprit was deeper: it was an architectural "best practice" that had become a bottleneck in a new context.

The Root Cause: The "Double Pooling" Trap

In a Serverless architecture, database connection management is a major challenge. Because functions spin up and down instantly, they can easily exhaust a database's connection limit. The standard solution is to use an external transaction pooler. This middleware sits between your functions and your database, managing a pool of persistent connections.

When I moved to a Persistent VPS (Docker), I kept using that same external pooler.

However, my new environment was fundamentally different. Unlike serverless functions, my Docker container stays alive. It uses an ORM with its own built-in, highly efficient connection pooling.

By pointing my persistent server to the external transaction pooler, I was effectively double-pooling. Every single query was forced through an extra middleware layer, incurring unnecessary SSL handshake negotiations and processing overhead, instead of holding a direct, persistent connection open.

The Fix

The solution was deceptively simple: Switch to the Direct Connection.

I updated my database connection string to bypass the external pooler and connect directly to the database server's standard port.

Before: App -> ORM Pool -> External Pooler (SSL Negotiation) -> Database
After: App -> ORM Pool (Persistent Connection) -> Database

The Result

The moment the change was deployed, the latency dropped from 350ms to 60ms.

By removing one unnecessary layer of "best practice" that no longer applied to my architecture, I achieved an 80% reduction in latency and a significantly snappier user experience.

The Lesson Learned

"Best practices" are not universal truths; they are context-dependent solutions.

What is a life-saver in a Serverless environment can be a performance killer in a Containerized one. Always audit your configuration and middleware when changing your underlying deployment architecture.

I'm currently building **HabitBuilder, a privacy-first habit tracker that focuses on flexible consistency rather than rigid streaks. Check it out at habits.planmydaily.com.

DEV Community: Kabeer N Shah

How I Slashed API Latency by 80% (350ms -> 60ms) by Ditching Serverless