*A guest blog post for \[GraphQL Editor blog]
(https://graphqleditor.com/blog/) by Kuba Kamiński from* [InfoTech](https://technikum.infotech.edu.pl/) 

We are living in a world in which technology changes every day. The web pages older than 3 years for us it is something old and out of date. It's not surprising that web pages should be upgraded every day to become more user-friendly, efficient, aesthetic and secure. Abilities that give us these possibilities are accessible by modern web technologies. It’s important for web programmers who want to stay at the top of their game and for newcomers looking for their first job. Today we will be looking at the most wanted of them in 2020. So the web programming frameworks are divided into three groups: frontend, backend & data layer.

## FRONTEND LAYER

At the overlap called *frontend frameworks*, we can see the top 3 of the most used web languages. These are the most appreciated frontend frameworks by respondents:

### React

[React](https://react.dev/) is a JavaScript framework that provides an option to create a user interface. React was released on March 1, 2013. It is declarative to make a work painless to create interactive UIs. As we can observe the number of programmists that are using this language is increasing year by year. On the label, we can see the number of users that have tried React but would not use it again is quite small. React has a dominant position among frontend frameworks.

![React](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/blogpost/react-1730850181914.webp)

### Vue.JS

Vue.js is a progressive framework for building user interfaces. What changes Vue from others is designed from the ground up to be incrementally adoptable. The first release of vue.js was February 2014. The Vue.js wasn't quite popular since 2016. As we can see in 2017 people started the interest in this language. Still, this language is very low on usage in everyday tasks. The number of people that are using Vue is increasing, but the number of users willing to learn is lowering year by year.

![Vue.js](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/blogpost/vue-1730850192887.webp)

### Angular

Angular is a cross-platform, fast and very performant frontend framework allowing you to quickly create UI views. Simple, yet powerful template syntax, high-performance, complex choreographies makes Angular a solid player among frontend frameworks with a pretty strong community using it on a daily basis.

![Angular](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/blogpost/angular-1730850143732.webp)

## BACKEND LAYER

At the tuck called “back end frameworks” under it, we got seven other tucks with the language but I will focus on the top 3. Upcoming languages are:

### Express

[Express](https://expressjs.com/) is a Node.js web application framework that provides a robust set of features for web and mobile applications. Express is a front-end framework that uses HTTP utility methods. The number of peoples that are using it on a daily basis is pretty high.

![Express](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/blogpost/express-1730850155843.webp)

### NEXT.js

[Next.js](https://nextjs.org/) is a static site generator with a lot of useful features like customizable server, routing, plugins as well as complete control over Babel and Webpack. Next.js is relatively and its popularity hasn't skyrocket yet but I am sure it will very soon.

![Next.js](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/blogpost/next-1730850175647.webp)

### Koa

[Koa](https://koajs.com/) is a new web framework designed by the team behind Express, which aims to be a smaller, more expressive, and more robust foundation for web applications and APIs. The number of users that are using koa is still low but it's definitely a framework to follow.

![Koa](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/blogpost/koa-1730850169485.webp)

## DATA LAYER

At the tuck called data layer, we can see under it more overlaps with the names of the programming languages to work on data layer:

### Redux

[Redux](https://redux.js.org/) is a data layer programing language that works as a javascript apps container. It’s centralizing all your apps to let you undo/redo state persistence. Redux lets you easily change things. The percents of users using Redux is increasing rapidly. In the two last years, the percentage of people that never heard of it didn’t increase enough.

![Redux](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/blogpost/redux-1730850187362.webp)

### GraphQL

[GraphQL](https://graphql.org/) is an amazing opportunity to maximize your efficiency on your web page. GraphQL is a query language for your API, and a server-side runtime for executing queries by using a type system you define for your data. GraphQL was getting his fame in 2017 when the number of users that didn’t know this language downgrade by almost half. The number of voters that want to learn it was highering in the years 2017-2018 but in 2019 the percent lowered and the percent of the users that are using it on a daily basis was bigger.

![GraphQL](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/blogpost/graphql-1730850161922.webp)

Most wanted web technologies of 2020

As GraphQL's premise was well-received by the dev community a new ecosystem of GraphQL-facilitating tools is growing rapidly. Libraries, editors, generators are showing up regularly having one thing in common, to make GraphQL adoption an easy-ride. GraphQLize is one of them.

## What is GraphQLize?

**GraphQLize** is an open-source library JVM library written in Clojure with Java interoperability, aiming to simplify the process of exposing GraphQL APIs over relational databases like **PostgreSQL or MySQL**. How does it work? GraphQLize is generating the GraphQL schema & queries resolvers using JDBC metadata. So basically GraphQLize will help provides **fully-featured GraphQL implementation with just a few lines of code**.

## Getting started

GraphQLize currently supports:

* Postgres 9.4+
* MySQL 8.0+

Getting started is quite simple. In general, you will need to:

1. Add the GraphQLize dependency to your project.
2. Initialize GraphQLize Resolver providing the Java SQL data-source.
3. Add a GraphQL API endpoint and use the GraphQlize resolver

The actual implementation of these steps will vary based on which language and framework you are using. Right now GraphQLize works with:

* Java,
* Kotlin,
* Scala,
* Clojure.

The detailed implementation guide is available in GraphQLize official documentation.

## How it works

### Types & fields

**GraphQLize uses JDBC metadata to generate [GraphQL type](/docs/what-is-graphql/)s & queries**. It takes your database and for every table & view, it generates a [GraphQL type](/docs/what-is-graphql/). The `field` names of a generated GraphQL `type` represent the column names of the corresponding database table or view. GraphQLize generates the field name by converting the column name to its camelCase version. Standard GraphQL scalar types, as well as some custom scalar types, are supported.

![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/postgresql-1730823490666.webp)![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/mysql-1730823596250.webp)


###### Source: graphqlize.org/docs

### Supported relationships

GraphQLize successfully identifies the relationships between tables in our database & use them to generate GraphQL schema containing appropriate fields.

![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/one-one-1730823540257.webp)![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/one-many-1730823561181.webp)![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/many-many-1730823576547.webp)


###### Source: graphqlize.org/docs

## On its way to being production-ready

GraphQLize is in its alpha stage aiming to gather as much feedback from the communities as possible. GraphQLize codebase & API are not stable yet and there might be some breaking changes coming. GraphQLize team claims it will be production-ready in a few months so stay tuned!

GraphQLize - generate GraphQL API from PostgreSQL/MySQL databases

If you’ve ever struggled to find vulnerabilities in your GraphQL code, this tool should be able to help. **InQL Scanner**, developed by [Doyensec](https://www.doyensec.com/) Research Island initially for their internal use, is now free to use and [available on GitHub](https://github.com/doyensec/inql). InQL Scanner is a stand-alone security tool, but its use can broaden by using it as a Burp Suite extension. It enables you to quickly extract and inspect metadata information. You can then more easily identify security issues which due to the descriptive nature of GraphQL would be otherwise hard to detect.

## What does it do?

Using InQL command from Python will result in issuing an Introspection query for **queries**, **mutations**, and **subscriptions**, as well as their respective fields and arguments. Optional arguments include targeting Remote GraphQL Endpoints, accessing API Authentication Key, replacing known GraphQL argument types with placeholder values, and generating documentation. The results can be generated in HTML or JSON schema formats.

![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/secure-graphql-1730828891156.webp)

##### Source: [undraw.co](https://undraw.co/)

## Burp Suite Extension

As Doyensec is considering integrating InQL with [Burp’s BApp Store](https://portswigger.net/bappstore), it is good to have a closer look at the functionality of the extension. According to the creators of the scanner, it enables you to:

* Search for known GraphQL URL paths; the tool will grep and match known values to detect GraphQL endpoints within the target website,
* Search for exposed GraphQL development consoles ([GraphiQL](/graphql-playground), [GraphQL Playground](/graphql-playground), and other common utilities),
* Use a custom GraphQL tab displayed on each HTTP request/response containing GraphQL,
* Leverage the template generation by sending those requests to Burp’s Repeater tool,
* Configure the tool by using a custom settings tab,

while maintaining the basic functionality of the tool described in the last paragraph. Instructions on how to use the tool, examples of documentation pages, and templates generation are available on [InQL GitHub page](https://github.com/doyensec/inql).

## Are there any downsides?

InQL is definitely worth trying out and running your code through it. InQL Scanner itself is a handy tool, however, its functionality seems to be limited in the stand-alone version. Using it as a Burp Suite extension significantly increases the scope of the tool’s functionality. And if you’re not satisfied with Burp’s essential manual tools, acquiring an extended license will cost you \~ €349 per user, per year. As GraphQL is rapidly growing in popularity, we should expect that there will be more and more people taking advantage of its limitations. Securing your code may be a good investment now before the frequency and severity of the attacks against it increases.

InQL Scanner - find security flaws in your GraphQL code

*A guest blog post for \[GraphQL Editor blog]
(https://graphqleditor.com/blog/) by Marcin, Adam & Norbert from* [InfoTech](https://technikum.infotech.edu.pl/) 

***

Awaited by everyone, the ninth version of Angular carries with it a lot of news and features. Primarily, Ivy became official compiler and functionalities brought into it, significantly improved performance and also streamline the process of debugging, testing and building web applications. In addition, changes were made to the entire framework.

## Project Ivy has arrived

[Angular](https://angular.io/) is one of the best open-source frameworks that allows building web apps. Developed by Google, it has evolved over the years into versatile framework development, having all the necessary tools and resources to create web applications.

The biggest change introduced in Angular 9 is the replacement of the existing ViewEngine (VE) compiler with the [Ivy compiler](https://v12.angular.io/guide/ivy). In short, it is a tool that will be crucial for the further development of Angular and that has allowed eliminating several errors with large bundles and application performance resulting in a significant performance jump.

![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/frameworks-1730833084826.webp)

##### Source: [undraw.co](https://undraw.co/)

In Angular 8 to activate Ivy you had to add the following lines in the tsconfig.json file:

```ts
"angularCompilerOptions": {
 "enableIvy": true
}
```

In Angular 9 as Ivy became the default compiler this is no longer necessary. Ivy is radically different from anything we have seen in mainstream frameworks because it uses incremental DOM, and it upgraded since 8th versions and offers numerous advantages as:

* Improved building,
* Easier debugging,
* Faster testing,
* TypeScript 3.7 support,
* Improved type checking,
* IDE & language service improvements.

and our personal favorite which is ...

## Improved bundle size

Ivy is reducing the size of JavaScript packages which is a great improvement for programmers trying to speed up their applications. Smartphones and other similar mobile devices make up about half of the websites' traffic worldwide. A large proportion of these mobile devices gain access to websites from locations with slow internet connections. Sadly this is still a major issue that needs to be considered while building an app. Rebuilding existing API to reduce the number of resources they need to download and increase application performance for mobile users could turn out to be quite costly and can pose an unexpected risk to their projects. Of course, there is always a [GraphQL](https://graphqleditor.com/) but since you need to convince your team first it takes time. Taking all that improved bundle size feature turns out really useful! If you would like to check in detail what has changed make sure to visit angular's official blog about the Angular 9 update.

![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/ivy-size-1730833111504.webp)

##### Source: angular.io

## Update today

It’s the biggest actualization for about three years, so do not feel overwhelmed.
If you haven’t updated your projects yet, [update.angular.io](https://update.angular.io/) might come in handy! Certainly, working on a refreshed framework will be much more pleasant from now on. The mass of changes inevitably also heralds a lot of problems, but certainly, the next updates bring necessary corrections and patches. We wish you fruitful work!

What’s new in Angular 9?

GraphQL was publicly released in 2015. Following this, a new ecosystem began to shape around it as it's premise was well-received by the dev community. GraphQL is basically a **query-language for your API** which is language & database-agnostic. A GraphQL query is a string sent to the runtime that returns JSON to the client. This simple idea began the creation of a wide set of open-source libraries, tools, clients etc., aiming to make using GraphQL an effortless experience.

**GraphQL popularity is constantly rising**. As the number of companies incorporating GraphQL is growing, the awesome tools supporting GraphQL are being developed daily. gqless is one of them!

![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/gqless.webp)

## How does it work?

**gqless** is an awesome GraphQL client built by Sam Denty. It's allowing you to wrap components in `graphql()` which makes gqless perform an additional render of your entire application with all the available GraphQL objects, but without the data i.e.:

* Arrays will have a length of 1
* Scalars will return null

After this is done the gqless will generate queries & fetch data to re-render the whole app with the newly available data as a final outcome.

gqless is a new & very interesting approach to a GraphQL client offering:

* **Invisible data fetching** - runtime generated queries with JS getters
* **Strongly typed** - built-in TypeScript support
* **Production-ready features** - it offers built-in cache,e extensions and more

![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/code.webp)

##### Source: gqless.dev

Try gqless and find out how enjoyable & easy it is to use GraphQL with auto-generated queries offered by gqless.

```ts
yarn add gqless
yarn add @gqless/cli -D

# or
npm install gqless
npm install @gqless/cli --save-dev
```

Have fun!

GQLess - a GraphQL client without queries

The Guild is an open-source group focused on enabling developers to maximize the benefits offered by GraphQL. [The Guild](https://github.com/the-guild-org/Stack) stands behind such notable GraphQL libraries as:

* GraphQL Code Generator
* GraphQL Inspector
* GraphQL-CLI

and other useful packages. A couple of days ago the Guild revealed their latest project - [GraphQL Mesh](https://github.com/ardatan/graphql-mesh).

## GraphQL Mesh

I believe this library may solve one of the most important issues standing in the way of global GraphQL adoption which is a fear of the unknown. The reason many developers haven't decided to try GraphQL is some uncertainty about the possible implementation issues that might arise during the transition process, with GraphQL Mesh you can easily use GraphQL specification with legacy API services!

![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/gql-m-1730840546961.webp)

##### Source: [Medium/The-Guild](https://medium.com/the-guild/graphql-mesh-query-anything-run-anywhere-433c173863b5)

## How it works

**GraphQL Mesh** is an open-source library with a goal to provide developers access to services using other API specifications like **openapi/Swagger, json-schema, SOAP, gRPC, SQL, Mongoose, GraphQL, Federated GraphQL, queue systems, SQL** with GraphQL queries, mutations & subscriptions without changing the source service.

In short GraphQL Mesh takes your existing services’ APIs specification and tries wrapping it with a GraphQL layer. But it doesn't stop here. GraphQL Mesh allows you to easily extend or modify your new schema, providing a fully-typed GraphQL SDK. This makes working with your new schema a lot easier as you are sure on any step that you are using the right object structure.

## Local schema vs Gateway

The output of GraphQL Mesh is a generated code that you can use both ways as:

* **Local Schema** - import it from the autogenerated directory and use GraphQL execute to run queries and mutations locally in your application putting GraphQL engine in charge of fetching & running data from your source API.
* **Gateway** - use your new schema as a shared gateway for multiple applications and run it on your own server which would be responsible for all schema operations.

Whatever you prefer to make sure to check a [detailed description of how it works & usage examples](https://medium.com/the-guild/graphql-mesh-query-anything-run-anywhere-433c173863b5) provided by the Guild & keep in mind that GraphQL Mesh is in still its early stage so there might some breaking changes coming.

Guild members have been using GraphQL Mesh for a while internally for their customers and they claim it has been a huge upgrade. If anything was holding you back from trying GraphQL now you have lost your excuse! Try GraphQL Mesh today :)

GraphQL Mesh - a new library from the Guild

Node.js is the most popular choice when building the backend for your app, no matter if you prefer a traditional REST API or using it to build something modern like the GraphQL server.

## Node.js

Node.js is a JavaScript runtime using an event-driven I/O model which makes it extremely efficient when it comes to making scalable network applications. It's cross-platform, so whether you are building a mobile app, web app or IoT, Node will do the job. It's light, it's scalable & it delivers! Whether you are building a side project or working on an enterprise app Node.js will fit your needs.

![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/node-1730833354275.webp)

##### Source: [undraw.co](https://undraw.co/)

## Best practices

Node.js offers a lot, but to bring to the best you need to know and follow its best practices. If you are wondering where to find them the awesome open-source community is here to help!

This repo is [the largest compilation of best Node.js content](https://github.com/goldbergyoni/nodebestpractices) available online. It contains:

* more than 80 best practices,
* useful style guides
* architectural patterns

As it's maintained by the community the "Node.JS Best Practices" is growing rapidly and new pull requests with fresh Node.js content are being created on a daily basis.

Best practices are divided into 7 groups of which each of them contains numerous good practices gathered from the community:

1. Project structure
2. Error handling
3. Code style
4. Testing & Quality
5. Going to production
6. Security
7. Performance

Each good practice contains a TL;DR summary as well well as a link to extended content including:

* detailed information
* code examples
* important quotes from different sources

Awesome, right? Rember to show the repo maintainers some love and leave them a star or contribute if you have some useful Node.js tips!

Node.js best practices

Yesterday **Nat Friedman the CEO of GitHub** announced that they have signed an agreement to acquire npm.

[npm](https://www.npmjs.com/) is the world’s biggest software registry. The npm team maintains many software development tools and is a critical part of the [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript) ecosystem. Thanks to the contributions of the open-source fans from the whole world npm stats look impressive, with:

* over **1.3 million packages** hosted
* more than **75 billion downloads a month**

npm is definitely an interesting acquisition target for a tech giant like Microsoft, who has recently acquired the GitHub Inc. GitHub declared that their goal is to help npm continue to expand to meet the growing needs of the JavaScript community.

![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/github-npm-dev.webp)

## Is it a good or bad thing?

It's really difficult to assess. The web communities are full of mixed opinions. Some of the users are feeling enthusiastic about the acquisition, showing as an example that GitHub is doing really great since being acquired by Microsoft or that the npm company is in a mess and this acquisition could possibly put the back on the right track by having such organization as GitHub as a partner.

On the other hand, are people that think that this could be harmful to the software ecosystem as the acquisition means that some of the core elements of the NODE ecosystem being own by such giants as Microsoft could be a threat, which seems to worry an open-source community:

![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/pypi.webp)

##### Source: [@dstufft](https://twitter.com/dstufft)

Is it a good or bad thing? Should we be worried or excited? What are your thoughts?

GitHub acquired npm

A couple of days ago the CEO and founders of [Sequoia Capital](https://www.sequoiacap.com/), one of the biggest VC standing behind such success stories as **Dropbox, LinkedIn or Stripe**, has openly published a letter they have sent to their partners providing guidance on protecting their business as well as dealing with consequences of the spreading effects of the coronavirus.

Sequoia businesses are present in many regions around the world so they are gaining first-hand information on the impact coronavirus has on global business and the challenges companies need to face as a result of the virus outbreak. So far the main problems global business needs to face are identified as follows:

**General slow-down of any business activities**
Many companies have experienced a significant slow down in their business growth, some of them will probably have problems meeting their planned goals for Q1-2020.
![General slow-down of any business activities](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/blogpost/global-slowdown-1732203058060.webp)

##### Source: [undraw.co](https://undraw.co/)

**Disruptions of the supply chain**
China is the world's largest supplier of ... many goods. The scale of an industry lockdown in China is huge and its seriously affecting the global supply chain. The modern software industry might not feel the slow-down as much as other sectors as it's not influenced by the supply chain distribution but is still exposed to the risk indirectly.

**Business trips & meetings cancelations**
The no-travel policy has been applied to many companies. Some of them are banning all international travels, some just those non-essential for their businesses.

![Business trips & meetings cancelations due to coronavirus](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/blogpost/no-travel-1732203038846.webp)

##### Source: [undraw.co](https://undraw.co/)

Sequoia Capital team suggest questioning each assumption crucial to your business functioning especially those: **cash runway, fundraising, sales forecast, marketing spend, headcount, capital spending.**

Remember that as with all crises, revenue and cash levels always fall much faster than expenses. Be prepared to respond to changing circumstances and remember that same as in nature the most adaptable to change will survive. IF you want to read the full letter sent out by the VC, it's available on [Sequoia Capital Publications on Medium](https://medium.com/sequoia-capital/coronavirus-the-black-swan-of-2020-7c72bdeb9753).

Be vigilant, stay healthy & keep your business in good health!

COVID-19 - what does it mean for the dev world

Since its public release in 2015, GraphQL has been on the rise both in popularity and widespread use. The addition of the data graph changed the development process forever, bringing together data and services in a comprehensive and secure way. An ever-growing number of companies have recognized its vast capabilities, with such entities as Shopify, Microsoft or Yelp adding GraphQL to their development stacks.

GraphQL is alive and well, but how did it grow from a hermetic language used by very few to a widely recognized, almost indispensable tool? It wouldn't be here without quite a few success stories surrounding it.

A perfect example would be a recent migration of Airbnb's API. It has been discussed at length by [Brie Bunge, one of their software engineers, at GraphQL summit](https://www.youtube.com/watch?v=pywcFELoU8E\&feature=youtu.be), where she described the process in some detail. I wanted to take a look at some of the distinct advantages of using GraphQL in these operations in the hope that you, dear reader, might find a solution to one of your problems.

![Migrating from REST to GraphQL](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/blogpost/graphql-restapi.webp)

##### Source: [undraw.co](https://undraw.co/)

## Better data access

The adoption of GraphQL for their API resulted in quicker access to data and a much more enjoyable interface. Thanks to the step-by-step approach to migration, with hardly any downtime during the whole process. Instead of trying to convert preexisting code at once or even rebuilding from the ground up, Airbnb opted for gradual changes. Consequently, this allowed for a smooth transition without the need to put any services on pause.

## Over-fetching problem

Another improvement gained through switching over to [GraphQL](https://graphqleditor.com/) was the significant reduction in over-fetching. The data has been shaped in a way that doesn’t allow for requesting any more than is needed in a particular instance. This severely reduces unnecessary costs that may have been incurred beforehand, something that must be considered when designing data architecture.

After the whole conversion process was complete, the result was a dependable, streamlined and far-reaching tool. It is able to quickly and reliably access requested data by combining the strengths of its components while getting rid of needlessly complicated code. Furthermore, should the need arise, Airbnb’s implementation of GraphQL is ready to be scaled within reason. According to [Adam Neary](https://medium.com/@AdamRNeary), another software engineer at the aforementioned company, other benefits [include](https://medium.com/airbnb-engineering/reconciling-graphql-and-thrift-at-airbnb-a97e8d290712):

* a strongly typed API schema,
* flexibility in field selection,
* cross-platform client-side development

... and many more.

Despite the indisputable gains from using [GraphQL](https://graphqleditor.com/), this project is far from complete. There are numerous improvements that can be developed sooner or later.

By reshaping the schema into a more data-centric one, they hope to cut down on duplicate requests, further increasing the efficiency and speeding up the caching, which has been a major bottleneck up till then.

This is but one of many examples of GraphQL being a prime choice for data handling at a major company. Nearly a thousand businesses from various branches using this language for all their dealings with queries, showing just how flexible and efficient it is.

The advantages of migrating to GraphQL

Another piece of great news for the GraphQL community surfaced last week. A San Francisco-based startup **Hasura Inc. announced a $9.9M Series A investment!**

Originally **Hasura** was a company aiming to help developers to simplify Kubernetes, but over time the team has realized that there was a much bigger problem they could address - data access.

Application developers need better access to data sitting in databases.  The Hasura team wants to solve that issue with the help of **GraphQL**, so they have pivoted into an open-source service that takes your databases & with a little bit of configuration allows you to deploy a production-ready GraphQL backend.

![](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/media/hasura-1730752491690.webp)

##### Source: [hasura.io](https://hasura.io/)

Hasura's software downloads count is soon going to hit a stunning **30 million**! Its open-source software is used by the thousands of development teams in the biggest wide variety of industries including aerospace and healthcare.

The new funding would let the company raise its headcount which currently oscillates around 40 employees. This would allow them to scale the number of supported database types as well as prepare for the launch of its new enterprise version which should appear on the market this year. As mentioned on [Hasura's GraphQL blog](https://hasura.io/blog/hasura-2020-the-next-phase-of-our-journey/) the biggest goals on their road map as for now are:

* Serve the needs of their production & enterprise users on a level better than ever before
* Deliver the GraphQL features that the Hasura community wants
* Expand the Hasura experience to other databases
* Invest in Hasura community

***

### Keep up doing a great job, congrats to Hasura team! :)

***

Hasura lands a $9.9M to simplify GraphQL development

One of the core notions of using [GraphQL](https://graphqleditor.com/) is a schema. It strictly defines the potential an API might have by forming a set of concepts and relations between them. Another crucial function of a schema is regulating how and by using which action data can be accessed.

Designing a schema is one of the first steps in the development process, casting a shadow over the following tasks. Due to how many areas are affected by a schema, later on, its architecture should be carefully planned. This, hopefully, leads to a naturally evolving, intuitive, and most importantly secure product.

[![GraphQL Schema](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/blogpost/schema-1730849614480.webp)](https://graphqleditor.com/)

##### Source: [undraw.co](https://undraw.co/)

## Scaling

Attempting to adjust a project which wasn't designed with greater scope in mind can be quite a headache. Adding something which seems inconspicuous to the end-user may involve a long list of tedious tasks. Deprecating pre-existing concepts, adding new ones only to be renamed a while later, keeping track of what has and what has not been yet modified. This process only gets more complex with every such change required. This can be avoided by following a few simple rules in scalable schema design.

[![Scaling schema-based project is easier](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/blogpost/scale-1730849610896.webp)](https://graphqleditor.com/)

##### Source: [undraw.co](https://undraw.co/)

##### Keep it simple

The goal of using [GraphQL is to create something transparent](https://graphqleditor.com/blog/what-offers-graphql-api/), easy to understand for everyone involved. However, this is made impossible if a schema can be compared to a labyrinth of connections and sources of data. Think about the developer who comes after you have moved on to other projects. An example of good practices can be using input object type for mutations.

##### Force yourself to be adaptable

To avoid the aforementioned headache in scaling, a schema should be easily adjusted to specific, often unforeseen, requirements. It is often the case that many concepts must be deprecated at once, whereas other ones need to be added without breaking the rest. A good way of doing this is using the tools given by [GraphQL](https://graphql.org/) itself, as opposed to creating one's own. Custom-made tends to be more convenient at the time, but it is less comprehensive looking from the outside.

##### Be creative & specific

Being a little bit more creative when designing a schema tends to pay off in the long run. Instead of going for the easy way out and using something generic, make the type name more specific. When in doubt, consult other people involved in the project, they may have some interesting ideas about how and for what reason you should name a concept in a certain way.

## Security

Carelessly drawn-up schemas may create various possibilities for malicious attacks in different ways. An example of such behavior is exposing data in unanticipated ways.

![Schema security is a crucial issue](https://graphqleditorcms.fra1.cdn.digitaloceanspaces.com/graphqleditorcms/blogpost/security-1730849617496.webp)

##### Source: [undraw.co](https://undraw.co/)

##### Think about proper pagination

One of the preventative measures can be proper pagination. This is a feature which is not provided by the language itself, it is mostly left to the imagination of the developer. There are many different ways in which pagination can be implemented, which makes the choice that more difficult. It is imperative to take into account the needs of the project, rather than personal preference.

##### Don't overload the client-side

Allowing the clients to manipulate data is generally frowned upon since it can give birth to a multitude of issues. It is a much better idea to keep as much as possible server-side, most preferably batched in a single large request, as opposed to multiple small ones. This has a two-pronged effect: reduces the amount of data that needs to be repeatedly loaded, and simplifies the result for the end-user.

Do not leave schema design to chance. Make it a group project, spend a couple of sessions together, brainstorming ideas and collaborating with everyone who has something to do with all the data. Hopefully, this leads to a good schema:

* one that is functional,
* malleable and easy to understand.

Future you will surely thank you later.

***

* A guest blog post for [GraphQL Editor blog](https://graphqleditor.com/blog/) by Carl Matte;
  Sources: [Do’s & Don’ts for your schema and GraphQL operations](https://www.youtube.com/watch?v=fG8zy1OROp4), [atheros.ai](https://learning.atheros.ai/blog/graphql-best-practices-for-graphql-schema-design), [apollographql.com](https://www.apollographql.com/blog/backend/schema-design/graphql-building-evolvable-schemas)

Blog