Mastering Data Fetching with GraphQL: Overcome Over-fetching & Under-fetching

Overcome Data Fetching Pitfalls

In the grand puzzle of software, APIs are the missing pieces that bring everything together. Yet, developers often find themselves caught in a tug-of-war between too much and too little data—the classic overfetching and underfetching duo.

Enter GraphQL, the superhero of data-fetching, giving developers the superpower to ask for exactly what they need. Unlike the strict rules of REST, adapting to this method lets developers tailor their requests, turning GraphQL data fetching into a customizable adventure.

Join us on a journey to untangle the complexities of over-fetching and under-fetching. It’s time to see how GraphQL transforms the API game, where every query is a unique request and developers hold the reins of data control. Let’s dive into the puzzle-solving magic of GraphQL and GraphQL API benefits that can be leveraged to boost performance!

What is Overfetching?

Imagine ordering a specific dish at a restaurant, and the chef, in a burst of enthusiasm, serves you the entire menu! That, in the realm of APIs, is overfetching—getting more data than you actually need. 

Picture this: you ask for a list of usernames, and instead, the API bombards you with the entire archive, forcing you to sift through heaps of unnecessary information.

This overindulgence not only contradicts the very essence of using APIs (which is supposed to make life easier!) but can also become a pain in a data-limited world. It’s like paying for a compact car and getting a limo—in a network where every extra byte costs, the headache intensifies.

What is Underfetching?

Underfetching in the API realm is akin to asking for a weather forecast and getting just the temperature—no mention of rain, wind, or whether you need an umbrella. It might not empty your wallet, but it’s definitely a hurdle of its own kind.

Here’s the scenario: you make an API request, and it hands you a snippet of data, but alas, it’s not enough to perform the desired function. Cue the need for another API call, adding a layer of complexity and extra processing time.

In the world of user experience, this spells trouble. Imagine a user trying to execute a function in an app, only to be met with a spinning wheel of delays. Frustration sets in, and there’s a high chance they’ll bid farewell to the underperforming app.

Tackling the Overfetching – Underfetching Dilemma

GraphQL emerges as a transformative solution, liberating developers from the constraints of overfetching and underfetching prevalent in conventional RESTful architectures. Unlike rigid RESTful APIs that impose fixed data structures on clients, GraphQL empowers them to fine-tune their data requests, effectively eliminating the dilemma of fetching excessive or insufficient information. Imagine a scenario where a client requires nuanced insights from diverse data sources. GraphQL enables a single, precisely crafted query to retrieve the exact data needed, minimizing unnecessary network traffic and maximizing operational efficiency. Furthermore, GraphQL’s introspective nature grants clients the ability to navigate schemas, tailor queries to precise requirements, and orchestrate seamless data exchanges across applications after suggesting specific runtimes.

As organizations embrace GraphQL, it serves as a strategic solution for enhancing data fetching efficiency and empowering client applications with precise data access capabilities.

GraphQL vs REST

Both overfetching and underfetching are commonly seen in systems that depend on the Rest API. Thankfully, GraphQL, which Meta introduced, is available to help you get past all of the Rest API’s limitations. As a matter of fact, GraphQL was found mainly to overcome these hitches in the REST API.

The structure of GraphQL is complicated, but it will return exactly what you expect from an API response. What causes both overfetching and underfetching is poorly formatted data. The process of GraphQL data fetching is what makes it a unique query language. It acts as a gateway between every API call and data transaction initiated. Once data is received, it is converted to the strongly typed format of GraphQL. It is required to understand the structure of GraphQL to know how it works and how it benefits the process of development.

GraphQL API Benefits

Below are instances of how GraphQL solves most of the drawbacks of REST APIs. Whenever a GraphQL vs REST debate surfaces, the following will solidify the fact that GraphQL data fetching indeed has an inclination towards performance boosting when it comes to software development:

1.    Promotes precision

One of the biggest GraphQL API benefits is that you can specify exactly what fragment of data is required for a specific function to be executed. Unlink the REST API, you don’t rely on predetermined responses from servers while using GraphQL. Instead, you get the power to define the structure of the response you want.

Example Query:

query FetchUserData {

  user(id: “yourUserID”) {



posts {






The above GraphQL query returns the data of a user that matches ID “yourUserID” including name, email and a list of posts with title and content.

2.    Eradicates Overfetching

GraphQL enables you to pinpoint exactly what information you are looking for while fetching data making it one of the solid GraphQL API benefits. This way, you are reducing the incoming overload of data and thereby increasing the overall response time. This will accelerate the execution of a function from a user’s perspective and make your software respond faster than ever.

Below is an example of how the response of the query mentioned in the earlier example will look like:


  “data”: {

“user”: {

   “name”: “Wickita Chan”,

   “profilePic”: “”,

   “posts”: [


       “title”: “Intro to Basics”,

       “date”: “2023-05-15”



       “title”: “Optimizing Queries”,

       “date”: “2023-06-02”






3.    Fix the hurdle of underfetching

What good is returned data if it is of no use after performing an API request? One of the downsides of underfetching is that you might want to initiate repeated requests to fetch the missed data you were expecting from an API call. With GraphQL, you can easily fetch all the data you want with just one single request. This feature of GraphQL data fetching will eliminate the burden on both the client and server sides, thereby boosting the development process.

4.    Overcome Redundancy

GraphQL allows developers to use fragments to define reusable units of fields. This not only promotes code organization but also prevents the duplication of field selections across multiple queries.

Below is a GraphQL fragment named “PostDetails” that can be used to define a reusable set of fields for a GraphQL type called “Post.”

fragment PostDetails on Post {



  author {




5.    Reusability of Queries

By applying fragments, developers can ensure that commonly used field selections are defined in a central location, mitigating the risk of unintentional over-fetching or under-fetching.

Below is an example of a GraphQL fragment:

query GetUserWithPosts {

  user(id: “123”) {



posts {





Final Word

In the relentless pursuit of efficient data retrieval, developers no longer need to grapple with the frustrations of over-fetching and under-fetching. GraphQL has emerged as a beacon of precision, empowering developers to craft queries that fetch exactly what they need—nothing more and nothing less. With its focus on putting control in the hands of developers, GraphQL is not just a technology; it’s a transformative shift toward a more efficient, precise, and developer-friendly approach to data querying.

Enter Expeed Software, where the rubber meets the road in the world of GraphQL applications. As a leading force in software development, Expeed has embraced GraphQL to transform the development process. Through strategic implementation, they have witnessed firsthand how GraphQL brings control back to developers, allowing them to craft queries that fetch exactly what is needed, no more and no less. The path of precision awaits, and with GraphQL, every query becomes a masterpiece.