Question 1

What is the N+1 query problem and how do I fix it?

Accepted Answer

The name describes the shape of the problem. One query fetches a list of records, and then one additional query runs for each record in that list to load something related. Fetching a hundred posts and then reading each post's author issues a hundred and one queries where two would have done.

It shows up most often with object-relational mappers that load relationships lazily. The code looks entirely innocent, because accessing a related object is just a property access, and nothing in the source suggests a network round trip is happening inside a loop. That invisibility is what makes the problem so common.

The standard fix is to tell the data layer up front which relationships you intend to use, so it can fetch them together. Most ORMs offer this as eager loading, and it typically resolves to either a join or a second query that collects all the related records at once. Either way the query count stops growing with the size of the result set, which is the property that actually matters.

In GraphQL the same problem arises naturally because resolvers run per field per item. The usual answer is a batching loader that collects the individual lookups occurring within one tick and issues a single query for all of them.

Detection is the part teams neglect. The symptom rarely appears in development, where the seed database has a handful of rows and a hundred fast queries still feel instant. It becomes visible in production, where latency scales with data volume. Log queries in development, or count them per request and fail a test when a route exceeds a threshold. That turns an invisible scaling problem into something a code review can catch.

It is worth noting that a small number of extra queries is not automatically a bug. The problem is specifically that the count grows with the result set, so it degrades exactly as the application succeeds.

Question 2

What is an ORM, and when should you not use one?

Accepted Answer

An ORM — object-relational mapper — translates between the objects in your program and the tables in a relational database, so you write method calls instead of SQL. What it gives you: Less

Question 3

Why does my database connection pool run out of connections?

Accepted Answer

Pool exhaustion means connections are being taken out and not returned as fast as they are requested. The symptom is a request that hangs and then times out waiting to acquire one, and it typically

Question 4

What are the best practices for using GraphQL with React?

Accepted Answer

Implementing best practices for GraphQL with React enhances performance and user experience. Key strategies include using Apollo Client, fragments, optimistic updates, and effective error handling.

Question 5

What techniques can I use to tune the performance of MongoDB?

Accepted Answer

MongoDB performance tuning techniques include indexing, sharding, schema design, connection pooling, query optimization, and hardware optimization. Each method enhances database efficiency and responsiveness.

Question 6

Why does offset pagination break, and what should you use instead?

Accepted Answer

Because OFFSET tells the database to fetch and discard rows — so it gets slower the deeper you go — and because the underlying data changes between requests, which makes results skip and duplicate

Question 7

Why is my PostgreSQL query still slow after adding an index?

Accepted Answer

An index existing and an index being used are different things. The planner chooses a strategy based on its cost estimates, and it will ignore an index whenever it believes a sequential scan will be

Related Questions