DEV Community: HkSolDev

Why Backend Apps Use Database Connection Pooling

HkSolDev — Tue, 14 Jul 2026 16:28:59 +0000

Why Backend Apps Use Database Connection Pooling?

Why not backend apps do not make a fresh database connection for every request.

At first I was thinking that when a request comes, the app can just query the database directly and get the result. But that is not how it works. Before the query even runs, the backend has to open a database connection, authenticate with the database, create a session, and use some database resources for that connection state

That means a database connection is not free. It takes time and also uses memory and CPU on the database side.

What a database connection is ?

When the backend wants to do some operation in the database, it first needs a connection to the database.

To make that connection, the backend uses database credentials, then the database authenticates the client, creates session state, and allocates resources needed for that connection. Only after that can the backend run the query.

So a connection is not just “send SQL and get result.” There is setup work before the actual query starts.

What happens when a backend opens a fresh connection

If the backend opens a fresh connection for a request, the flow is roughly like this:

User sends an HTTP request.
The backend opens a database connection.
The database authenticates that connection.
The backend sends the SQL query.
The database processes the query.
The database returns the result.
The backend closes the database connection.
The backend sends the HTTP response.

1. User clicks "Get Articles" button
2. HTTP request reaches your server           [0ms]
3. App creates database connection           [20ms]  ← Connection overhead
4. App authenticates with database           [10ms]  ← Authentication overhead
5. App sends SQL query                       [1ms]   ← Actual work
6. Database processes query                  [5ms]   ← Actual work
7. Database returns results                  [1ms]   ← Actual work
8. App closes database connection            [5ms]   ← Connection overhead
9. App sends HTTP response                   [1ms]

So in this flow, the query is only one part of the total work. Connection setup and teardown also add overhead.

Why doing that on every request is expensive

If we make the connection for reach request
First we have to go with all the above process for each connection the backend repeats this full process for every request, the extra overhead adds latency again and again. Under higher traffic, that also puts more pressure on the database because too many connections consume extra resources.

If one req take 2-8 mb of the space think about the 1000 of connection, Database might take 2-8Gb just for the connection overhead.|

That is why opening a new connection for every request is usually a bad idea for real backend systems. The app spends time creating and closing connections instead of just reusing them.

What connection pooling is

A Connection pooling is a cache of Database connection already open and ready to reuse.

Instead of creating a new connection for each request, the application borrows a free connection from the pool, uses it for the query, and then returns it back to the pool. This avoids paying the full connection setup cost every time.

So the main benefit of pooling is lower connection overhead and better control over how many active database connections exist at once.

How a request works with a pool

With a connection pool, the app does not always need to start from zero.

When a request comes in, the backend asks the pool for an available connection. If one is free, it uses that connection to run the query and then returns it to the pool after the work is done. Some pools create connections early, while others create them lazily and grow up to a configured limit.

This saves time because the app is reusing existing connections instead of building a fresh one for every request.

Common mistakes and limits.

Connection pooling is useful, but it also has limits.

Pool make Too large

If make more no of connection into the pool does not does not automatically make the app faster, instead we fallback to the same issue that we try to solve with the pool.

Connection Leaks:-

A connection leak happens when the app taken connection form the pool but never returned, so the pool slowly run out of the connection.

No Timeout settings:-

If all connections are busy and there is no proper timeout, requests may hang too long while waiting for a free connection.

Pool too small:

If the pool is too small, requests start waiting for a free connection. Then the app feels slow even if the database itself is working fine.

Ignoring slow queries:

A bad query can hold a connection hostage and block others.

Final thought

The main thing learned today is that connection pooling is not about making the database magically faster. It is about avoiding repeated connection setup cost and managing database connections in a smarter way.

So if a backend is opening a fresh database connection for every request, pooling is one of the first things to look at.

Understanding How AI Agents Work?

HkSolDev — Sun, 12 Jul 2026 00:58:20 +0000

What is an AI Agent?

The AI agent is a tool that helps the user to get the answer/info directly what he is seeking.

If we just talk in the context of coding only before the AI come coding is like a open book exam where writing code is like answering the question in the test and if you stuck you just open the book or go to internet and get the answer but even its a open book exam you must atleast have a basic idea where to look and the available answer is suit for you code you not its like you look for an Math query and you checking the chemistry answer.

What change after AI is that we all get our own guider who directly gives us the answer and relevant links to where he gets the answer for reference.

So we can say that AI Agent is a more of our personal guider which we can use in any way, anytime we want.

Workflow of AI Agents:-

So we see we can use the AI Agent at many places and more of a guider now, let’s see how the guider does things behind to help us.

Lets go with the example of the Open Book Test, and we user Our Guider AI Agent to clear the test.

So we Stuck in some questions and Now We need the help of our Guider to get the answer for the relevant question.

So the first question was whether our Guider needed to look at the Whole Book?

The answer is no as book may be very long and its just a example of book the data can be very long so machine/ AI Agent cant look whole data at once so there is limited size it can look at a time and that called Context Window and its depends on LLM some have big window and some has small

So the question may come now that the data is always more than the context window, so how can we store and get the answer?

The answer is we divided the book into small chunks, let’s say pages or more small (put 1000 words at a time together into the list), we do not need to always look through the whole data to get the answer

After dividing the Big PDF into small chunks, we pass the relevant chunks into the context window, and LLM can do the process

from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter

put the file path of the File //

file_path = "./example.pdf"

load the file by using the PyPDFLoader //

loader = PyPDFLoader(file_path=file_path)
docs = []

print("LOADER", loader)
// Loads the file
docs_lazy = loader.lazy_load()

for doc in docs_lazy:
docs.append(doc)

Here we do the Choose the Textsplitter which help us to do the chunking and we give what

is the size of our chunk and we overlap the chunk as the data not lost when the chunk end

text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)

Now we the splitter we make and made chunk of the docs we have on the basis of text

text = text_splitter.split_documents(documents=docs)

Why require to do Embedding:-

Now we do the chunking or divide the data into small parts, you think now just put it into the vector database and we're good to go. But that’s not true as it is like we just put the text into the database and if the query comes it’s not possible to get the relevant data from the database.

Take an example like Translation from English to Your Language

“The sun sets in the west”

Can its make sense if you translate the things word by word and say it may be, but its rare, most of the time it’s not you have to find the relation and semantic meaning for the words and how they are related to translate it well.

I don’t like, grammar, and i have a sensei who always corrects me.

So like in translation, we put the word based on its relation we put the chunking data in a way that the same meaning of words are closer to each other in the vector db so its easy and get the relevant data easily for the query.

Do not worry, this is all done by the LLM.

So far, we take a big file —> Divide the file into small chunks —> Do the Embedding of the chunks and put in the Vector Db.

from langchain_google_genai import GoogleGenerativeAIEmbeddings

use the QdrantVectore Store to store the vector embedding

from langchain_qdrant import QdrantVectorStore

Here we select the GoogleAi Embedder to make the embedding of our docs

embedder = GoogleGenerativeAIEmbeddings(
model="models/text-embedding-004",
google_api_key="Your Api key",
)

Now we make a vectore store

vector_store = QdrantVectorStore.from_documents(
documents=[],

The Url to which to connect

 url="http://localhost:6333",

The collection name we have in our store in which we put all our embedding

 collection_name="learning_langchain",

Give the embedder we make above

 embedding=embedder,

)

Now we have our store now lets put the doc in it we have and its make all the embedding and

All by itslef automatically

vector_store.add_documents(documents=text)

Retrieval & Generation -

When the user asks a query/question, the agent:-

When user asks a que/query, we can directly search the query in our database as user can ask anything, and its very hard and maybe the data we got is not fully correct to find what the user is asking about, so for this.

We convert the user query into an embedding.

Then we get the embedding of the query and search into our Vector Database for the relevant meaning word or similar semantic meaning.

After getting the relevant semantic meaning, we pass the ( relevant data + user query ) to our LLM and we got the result.

from langchain_qdrant import QdrantVectorStore

This we make to get the revelant data from our store

retriver = QdrantVectorStore.from_existing_collection(
url="http://localhost:6333",
collection_name="learning_langchain",
embedding=embedder,
)

Query give By the user

query = input("Ask the Doubt:=> ")

We put the query into our message array

message.append({"role": "user", "content": query})

This will Find the revelant data on the basis of out query form the Database

search_result = retriver.similarity_search(query)

Here we put the data we got from the retriver and put in message so our LLM have revelant data

and query to give us a better answer

message.append({"role": "system", "content": search_result[0].page_content})

Now just give the message to our LLM

res = client.chat.completions.create(
model="gemini-2.0-flash",
messages=message,
response_format={"type": "json_object"},
)

Here We see the query Result from Our LLM

print(res.choices[0].message.content)

Connect With me:-

Github:- https://github.com/hksoldev

LinkedIn :- https://www.linkedin.com/in/mrhemantkumarr/ Youtube

X(Twitter) :- https://x.com/hksoldev

Discord:- https://discordapp.com/users/1442491832591319182

Want to learn about Devops can anyone suggest where should start learn for free ?

HkSolDev — Thu, 23 Jan 2025 15:48:06 +0000

Want to prepare for an interview for react i am fresher i dont know where to prepare for an interview anyone please tell me

HkSolDev — Tue, 18 Jul 2023 12:34:11 +0000