adding feedback

Author: idalithb

website/src/pages/en/subgraphs/querying/best-practices.mdx

@@ -10,7 +10,7 @@ Use The Graph's GraphQL API to query [Subgraph](/subgraphs/developing/subgraphs/
 
 ### The Anatomy of a GraphQL Query
 
-> GraphQL queries use GraphQL language, which is defined in the [GraphQL specification](https://spec.graphql.org/).
+> GraphQL queries use the GraphQL language, which is defined in the [GraphQL specification](https://spec.graphql.org/).
 
 Unlike REST APIs, GraphQL APIs are built on a schema-driven design that defines which queries can be performed.
 
@@ -25,7 +25,7 @@ query GetToken($id: ID!) {
 }
 ```
 
-The expected response will return a predictable JSON response (when passing the proper `$id` variable value):
+which will return a predictable JSON response (when passing the proper `$id` variable value):
 
 ```json
 {
@@ -53,9 +53,9 @@ query [operationName]([variableName]: [variableType]) {
 > Important: Failing to follow these rules will result in an error from The Graph API.
 
 1. Each `queryName` must only be used once per operation.
-2. Each `field` must be used only once in a selection (you cannot query `id` twice under `token`)
-3. Complex types require selection of sub-fields.
-   - For example, some `fields' or queries (like `tokens`) return complex types which will require a selection of sub-field. Not providing a selection when expected or providing one when not expected will raise an error, such as `id`. To know a field type, please refer to [Graph Explorer](/subgraphs/explorer/).
+2. Each `field` must be used only once in a selection (you cannot query `id` twice under `token`).
+3. Complex types require a selection of sub-fields.
+   - For example, some `fields' or queries (like `tokens`) return complex types which will require a selection of sub-fields. Not providing a selection when expected or providing one when not expected will raise an error, such as `id`. To know a field type, please refer to [Graph Explorer](/subgraphs/explorer/).
 4. Any variable assigned to an argument must match its type.
 5. Variables must be uniquely defined and used.
 
@@ -104,7 +104,7 @@ For more alternatives, see ["Querying from an Application"](/subgraphs/querying/
 
 ### 1. Always Write Static Queries
 
-A common bad practice is to dynamically build a query strings as follows:
+A common bad practice is to dynamically build a query string as follows:
 
 ```tsx
 const id = params.id
@@ -122,10 +122,10 @@ query GetToken {
 
 While the example above produces a valid GraphQL query, it comes with several issues:
 
-- The full query is harder to understand
-- Developers are responsible for safely sanitizing the string interpolation
-- Not sending the values of the variables as part of the request can block server-side caching
-- It prevents tools from statically analyzing the query (ex: Linter, or type generations tools)
+- The full query is harder to understand.
+- Developers are responsible for safely sanitizing the string interpolation.
+- Not sending the values of the variables as part of the request can block server-side caching.
+- It prevents tools from statically analyzing the query (e.g.linters or type generation tools).
 
 Instead, it's recommended to **always write queries as static strings**.
 
@@ -153,10 +153,10 @@ const result = await execute(query, {
 
 Static strings have several **key advantages**:
 
-- Queries are easier to read, manage, and debug
-- Variable sanitization is handled by the GraphQL server The GraphQL
-- Variables can be cached at server-level
-- Queries can be statically analyzed by tools (see [GraphQL Essential Tools](/subgraphs/querying/best-practices/#graphql-essential-tools-guides))
+- Queries are easier to read, manage, and debug.
+- Variable sanitization is handled by the GraphQL server The GraphQL.
+- Variables can be cached at the server level.
+- Queries can be statically analyzed by tools (see [GraphQL Essential Tools](/subgraphs/querying/best-practices/#graphql-essential-tools-guides)).
 
 ### 2. Include Fields Conditionally in Static Queries
 
@@ -190,7 +190,7 @@ const result = await execute(query, {
 
 ### 3. Ask Only For What You Want
 
-GraphQL is known for it's "Ask for what you want” tagline, which is why it requires explicitly listing each field you want. There's no built-in way to fetch all available fields automatically.
+GraphQL is known for its "Ask for what you want” tagline, which is why it requires explicitly listing each field you want. There's no built-in way to fetch all available fields automatically.
 
 - When querying GraphQL APIs, always think of querying only the fields that will actually be used.
 - Make sure queries only fetch as many entities as you actually need. By default, queries will fetch 100 entities in a collection, which is usually much more than what will actually be used, e.g., for display to the user. This applies not just to top-level collections in a query, but even more so to nested collections of entities.
@@ -301,7 +301,7 @@ query GetTokensandCounters {
 const  { result: { tokens, counters } } = execute(query)
 ```
 
-Sending multiple queries in the same GraphQL request **improves the overall performance** by reducing the time spent on the network (saves you a round trip to the API) and will provide a **more concise implementation**.
+Sending multiple queries in the same GraphQL request **improves the overall performance** by reducing the time spent on the network (saves you a round trip to the API) and provides a **more concise implementation**.
 
 ### 6. Leverage GraphQL Fragments
 
@@ -364,8 +364,8 @@ When using the types generation tool, the above query will generate a proper `De
 
 ### Do's and Don'ts for Fragments
 
-1. Fragments cannot be based on a non-applicable types (on type not having fields)
-2. `BigInt` cannot be used as a fragment's base because it's a **scalar** (native "plain" type)
+1. Fragments cannot be based on a non-applicable types (types without fields).
+2. `BigInt` cannot be used as a fragment's base because it's a **scalar** (native "plain" type).
 
 Example:
 
@@ -406,9 +406,9 @@ fragment VoteItem on Vote {
 
 ---
 
-### How-to Define `Fragment` as an Atomic Business Unit of Data
+### How to Define `Fragment` as an Atomic Business Unit of Data
 
-> For most use-case, defining one fragment per type (in the case of repeated fields usage or type generation) is enough.
+> For most use-cases, defining one fragment per type (in the case of repeated fields usage or type generation) is enough.
 
 Here is a rule of thumb for using fragments:
 
@@ -476,19 +476,19 @@ GraphQL plugins streamline your workflow by offering real-time feedback while yo
 
 1. VS Code
 
-Install the [GraphQL VSCode extension](https://marketplace.visualstudio.com/items?itemName=GraphQL.vscode-graphql) to unlock:
+Install the [GraphQL VS Code extension](https://marketplace.visualstudio.com/items?itemName=GraphQL.vscode-graphql) to unlock:
 
 - Syntax highlighting
 - Autocomplete suggestions
 - Validation against schema
 - Snippets
 - Go to definition for fragments and input types
 
-If you are using `graphql-eslint`, use the [ESLint VSCode extension](https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint) to visualize errors and warnings inlined in your code correctly.
+If you are using `graphql-eslint`, use the [ESLint VS Code extension](https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint) to visualize errors and warnings inlined in your code correctly.
 
-2. WebStorm/Intellij and GraphQL\*\*
+2. WebStorm/Intellij and GraphQL
 
-Install the [JS GraphQL plugin](https://plugins.jetbrains.com/plugin/8097-graphql/). It significantly improves your experience while working with GraphQL by providing:
+Install the [JS GraphQL plugin](https://plugins.jetbrains.com/plugin/8097-graphql/). It significantly improves the experience of working with GraphQL by providing:
 
 - Syntax highlighting
 - Autocomplete suggestions