Hasura Reviews

My main use case for Hasura is that my application is a GraphQL application, and since connecting to the database directly through my UI, Hasura gives very excellent access to directly reach the database and get the request back without any API or endpoint creation. With the same endpoint, we can get considerable data from the database directly. A quick specific example of how I use Hasura in one of my applications is that our application shows the cards in the wallet, indicating how many points and gift cards the user has. When a user logs into our application and clicks on their gift cards, the UI makes a call directly to Hasura, where we calculate the particular user's details and collect the amount of the entire gift cards to return back to them. While doing that, we have several payment groups because a user can have different gift cards, for example Domino's or Amazon. While mixing them and providing the exact user those details, not allowing other users to access this user's specific details, Hasura is very helpful.

The best features Hasura offers are the permissions and the ability to connect to the database seamlessly when we use GraphQL, which Hasura handles exceptionally well. These features impact my day-to-day work positively, as they are tremendously helpful at the application level architecture design. However, the disadvantage revolves around performance. You need to upgrade to the Enterprise version to achieve better performance and ensure proper memory is assigned in your hosting container for optimal speed as required. Hasura impacts our organization positively by being extremely useful. When we create multiple actions and cache them with Hasura, the caching has proven to be more than helpful. Furthermore, integrating OpenTelemetry into our Node application with Hasura has the added benefit of tracking Hasura calls directly, which helps us monitor our performance effectively.

Hasura could be improved by enhancing the performance of the free tier version, particularly for small applications that can only accommodate around 500 MB. In my scenario, that would have made a noticeable difference.

I have additional comments about my use case and how Hasura fits into my workflow, as it has been helpful in terms of managing permissions for each table and role so that only specific roles can access particular columns. Creating REST API endpoints for each permission management task in internal application admin UIs can be burdensome, but Hasura allows us to handle permissions efficiently. Additionally, if you are using the free tier version, it tends to be slow. I have not used the Enterprise version yet, but regarding the free tier, your application will only achieve more than 40 or 50 TPS at maximum, so that is something to keep in mind when considering Hasura. When we implemented Hasura in our application, there was no prior framework, and we noticed significant advantages, especially given our need to manage numerous gift cards and user card details. Hasura simplifies making complex database queries that we would find difficult with our current relational database. Its features, including querying with parameters for equality, range checks, and uniqueness, lead to very fast results that the NodeJS application can handle easily. I would rate Hasura overall as 6.5 to 7 for the free tier version since I have not used the Enterprise one. It is pretty basic and simple, with anything above five being adequate. Hasura simplifies implementing complex queries needed for my application, and its permissions allow one user's cards cannot be seen by another user. That is why I conclude it is excellent for permission-focused applications, but the concerns regarding the free tier performance limitations mean you cannot achieve over 100 TPS. My advice for others looking into using Hasura is that if your application is not going to reach 50 TPS, then it is very good to use. I am rating Hasura overall as a 7 based on my experience with the free tier version.

Hybrid Cloud

Amazon Web Services (AWS)

In our trading application, we use Hasura mainly as a GraphQL gateway on top of Postgres to expose our data APIs quickly without writing any repetitive CRUD services. It has helped us accelerate front-end and back-end integration together while still keeping the authorization and business logic controlled through the roles of the back-end services.

For example, in our trading monitoring dashboard, traders need real-time visibility of orders and positions. Earlier, we had custom REST endpoints which required frequent data retrieval directly from the database and took more time. With Hasura, we exposed GraphQL on top of Postgres and used subscriptions for updates, so UI teams got the data faster and experienced less back-end work, which required fewer APIs.

One advantage is the speed, as front-end teams did not have to wait for separate REST endpoints anymore for any UI change. It removed a lot of repetitive CRUD service development, allowing the back-end team to focus on business logic.

The features I find most valuable are the auto-generated GraphQL APIs where we do not need to build repetitive endpoints, and the role-based authorization, which is useful in our banking use case, as different users have different levels of access. With GraphQL subscriptions, we get near real-time UI updates.

For us, the most important feature was the auto-generated GraphQL API with authorization. In our workflow, whenever a new trading dashboard or a new data view was needed, we did not have to build and maintain separate CRUD endpoints. Once the schema and permissions were configured by the users who made the Hasura changes, the front-end team could directly start consuming the data, which reduced back-end development time.

I appreciated the subscription feature for live screens because users did not need manual refresh for monitoring reviews. Overall, Hasura worked best for speed development and standard API exposure while core trading logic still stayed in the back-end.

Hasura has a positive impact mainly in speed and consistency, as teams could expose data quickly without creating separate APIs. There was better collaboration between both front-end and back-end teams, and centralized permissions and metadata management helped maintain consistency.

One area where Hasura can improve is handling complex business logic, and for observability and debugging, improvement is needed. Hasura can improve around complex workflow support and managing large-scale permissions.

A few things come to mind regarding documentation. Documentation is generally good, but for advanced production scenarios and architecture patterns, more real-world examples would help. Smoother integration and observability with monitoring and tracing tools would make troubleshooting easier.

One improvement I would like is better support for large-scale schemas, and for complex logic. For complex transactional workloads, we still keep business logic in back-end services, so Hasura needs to become more efficient for heavy workloads.

I have been using Hasura for the past two years.

Hasura is stable.

Hasura's customer support is reliable and good. Overall, we are able to interact without issues, and so far, we have not faced any that needed to be reported. I would rate the customer support as a 10 because we have not experienced any issues.

We did not track a formal Hasura KPI, but from a delivery perspective, we definitely saw a faster development cycle. For the data-driven screens, the front-end teams were less dependent on back-end teams creating new endpoints, so features moved faster, and it reduced the maintenance because we had fewer custom CRUD APIs to maintain.

We did not track a formal ROI metric tied to Hasura, but we see the value in time savings and faster delivery.

My advice would be to use Hasura when it provides the most value, such as when rapid API development and real-time data use cases are needed. My experience with Hasura was positive, and it has helped us accelerate development and reduce the effort around exposing and maintaining APIs. I would rate this review an 8.

Hybrid Cloud

Other

As an end-user of Hasura, we are using it within our projects. Our usual use cases for Hasura involve using it as an authorizer; instead of writing our own GraphQL schemas, we use Hasura, which is 10x faster, and we don't need to write as much logic ourselves. Hasura is a GraphQL engine tool that generates schemas automatically to connect with the database, so we do not need to manually write the schemas and APIs. We can directly integrate through our application, making the developer's job easier. Additionally, it connects very fast, with APIs being 10x faster compared to normal APIs.

The features I appreciate most about Hasura include the ability to connect to any database; we are using PostgreSQL, and it automatically generates schemas once connected to the tables. Hasura reads the tables and creates the schemas itself, eliminating the need for users to write their own schemas. Furthermore, it allows for authentication in multiple ways, such as Webhooks and JWT tokens, providing role-based authentication for data, which is a significant feature for us.

We do use Hasura's real-time subscriptions, and they have a substantial impact on our application's interactivity because, with subscriptions, there is no need to refresh the app whenever data changes. Hasura's subscription feature automatically updates data, making it very important for our workflow. All features provided by GraphQL are provided by Hasura, including subscriptions, mutations, and queries.

Hasura's granular data access control helps in securing sensitive information by implementing role-based authentication. For instance, if a user is set up with their username or user ID and email, they only have access to their data and nothing else, unless they are an admin or receive other specific permissions.

Currently, I cannot suggest improvements for Hasura, as it is evolving nicely, and they are releasing the latest versions. I have not encountered any bottleneck problems according to my business logic, and I find the UI and console to be very good, so I have not experienced any issues.

I have been working with Hasura for a considerable time.

Regarding stability and reliability, I find them to be very good since we have been using Hasura for the past three years without any downtime. I would rate stability between 8.5 to 9. It works very smoothly.

Hasura's scalability depends on how we configure it on-premises; we are using 10 servers according to our business logic and throughput needs. Despite high connection loads, Hasura manages well, and our servers may go down, but Hasura never fails and reconnects quickly. I can confidently say they manage scalability very effectively.

I have not had the need to communicate with Hasura's technical support yet.

Before using Hasura, we were utilizing our own custom APIs and schemas for the same use cases, without any other tools.

I did not evaluate other options before choosing Hasura because when I joined this company, they had already introduced Hasura. I am not sure if they did any research on alternatives, but I can confirm that I did not.

To evaluate the effectiveness of Hasura's event triggers, I use metrics such as the time taken for API calls, which we check using Postman, measuring in milliseconds.

I can only assess Hasura's value in integrating with microservices architectures from our experience, as we are only connecting one microservice with one PostgreSQL database. I cannot speak to how it performs with multiple microservices; however, it integrates very effectively with the database, and the process is straightforward.

The most significant benefit I have seen with Hasura is that it makes the developer's job much easier by eliminating the need to write custom APIs and schemas. It is 10x faster because they maintain some internal cache mechanisms efficiently.

I have used Hasura's official documentation, which is well-provided. If you are a skilled engineer, you can comprehend it effectively, but you need to know the jargon. I would give the documentation a rating of 7 because if someone is not that skilled, they may struggle to understand it without prior knowledge.

I would rate this review an overall 8.

I use Hasura for development purposes as a GraphQL engine that provides REST endpoints for data retrieval and mutation, integrated with our .NET application. It is incredibly fast for development because it combines GraphQL queries directly into a single SQL statement.

Hasura was used for the article pipeline page where GraphQL queries were created for fetching large scale data using the GraphQL endpoint directly from Hasura engine. With a million records of data, the retrieval is completed within a second using the GraphQL query.

There is an issue with HTTP transactions since HTTP is a stateless protocol, making it impossible to maintain transactions, which is the only drawback found in the GraphQL queries. Custom transaction methods were built to address this, and role-based query filters were also used, adding connections with the subgraph and Apollo Federated graph, treating it as a subgraph.

Hasura offers excellent features including role-based filtering, which eliminates the N+1 problem, making it easy to maintain schemas and ensuring fast retrieval and fast mutations.

The biggest feature that made the most difference for our team is schema maintenance. Hasura is really good for handling different migrations and schema changes. A custom migration task was built for Azure DevOps, which makes it easy to manage. Hasura engine also keeps track of migration numbers, making it simple to handle migrations, and adjusting role-based visibility for users when exposing certain fields or columns is straightforward.

Hasura has positively impacted the organization mainly by enabling fast retrieval of data through GraphQL, which is the main reason for using it.

Faster development cycles were noticed when comparing direct SQL queries and the overhead in the execution pipeline. Moving to the GraphQL query made data retrieval very easy.

The main improvement for Hasura is that it allows communication only through the REST endpoint provided by it. Since that is a stateless protocol, a way needs to be found to handle distributed transactions, perhaps like in EF Core where a transaction scope can be created. The HTTP protocol makes this difficult, so a better solution is needed.

I have used Hasura for almost four years.

Hasura is stable based on experience.

Hasura is scalable with the ability to use role-specific elements, and it is easy to specify the columns. Horizontal scaling is possible, and the necessary servers can be provided.

Direct communication with customer support does not occur since Hasura is owned by the company.

The architect team determined that Hasura needed to be used, which is why it was selected.

Since Hasura is maintained by the company, there is no concern about payment and other related matters.

The organization is seeing a return on investment, which is why it is promoting Hasura.

Other options like Hot Chocolate and ChilliCream were evaluated since the application is being built on top of .NET Core, but Hasura seemed easier to maintain.

The overall review rating for this product is 8.

Private Cloud

Microsoft Azure

My main use case for Hasura is for back-end data validation.

A quick, specific example of how I use Hasura for back-end data validation is that we had an integration project from one tool to another tool to Epic and how that data is flowing. All data was integrated in Hasura database. From there I use the queries to fetch the data and find out how the data is integrated and how it is working.

About my main use case with Hasura, I felt Hasura is a pretty user-friendly tool.

The best features Hasura offers include the way I can construct my queries because I use it for back-end validation.

What I appreciate most about constructing queries in Hasura is that the entire process is beneficial because it was easy compared to other databases where I can go to the table and select the columns and drag it and construct the queries. The flexibility and the speed are exceptional.

Hasura has positively impacted my organization because for this project, whatever project I'm working on where previously we were using the normal DB2 and which was a little complicated to use, Hasura made it very easy to understand the data flowing and data integration.

I'm still using it, so I'm unsure how Hasura can be improved. Perhaps its framework and structure-wise aspects could be enhanced. I feel it's good overall.

Regarding needed improvements, many developers feel that the complex workflow and validations can be difficult to manage at scale, and debugging access issues are a little confusing. These aspects could be fixed.

I've been working in my field for the last 17 years.

I have been using Hasura for about one to one and a half years.

Hasura is stable.

I'm not understanding what it is, analytic application; is scaling I would say something along those lines?

I have never tried to work with the customer support.

Before using Hasura, we used to use SQL DB2, and as I mentioned, it was pretty old and a little time-consuming. That's why we shifted to Hasura.

I have not seen a return on investment with Hasura because as a team member I used that one, and I'm not the best person to answer that. My manager would be better positioned to provide that information.

My experience with pricing, setup cost, and licensing is that I don't know about the cloud which one they used. About the licensing, I think the company provided it to us, so I don't know. The company worked on that one.

Before choosing Hasura, I am not certain. That decision was taken care of by our leadership team.

Since switching to Hasura, I would say there are fewer errors because if we make any error, a detailed analysis will be shown and we can identify and correct it, saving more time on that.

My advice to others looking into using Hasura is that it's a good choice; performance-wise it is really good, so I would tell others that you can use it. There will be some challenges such as poor indexing and some inefficient GraphQL queries, but Hasura itself is really fast, so I would definitely suggest it. I would rate this review a 7.

Private Cloud

Other

My main use case for Hasura is database connectivity and creating APIs. I can use an API for the database quickly without writing any code, which is a specific example of how I use Hasura for database connectivity and API creation.

The best features Hasura offers include the ability to directly integrate it with the front end, and the performance is quite good and fast.

Hasura has positively impacted my organization by boosting the productivity of the application in real time. It has also worked with real-time subscriptions where the performance was good, and queries were very fast.

The learning curve for Hasura is not straightforward, so it takes time to learn. This could potentially be simplified.

I have been using Hasura for four years.

Hasura is stable in my experience.

The scalability of Hasura is good, with no issues in that area.

Customer support for Hasura was quite good. I would rate the customer support a 10 on a scale of one to ten.

I have not used any solution in competition to Hasura, as that was entirely different.

On a scale of one to ten, I would rate Hasura overall an eight, perhaps eight to nine.

As of now, it is working well, and I do not see any strong improvement needed.

I have seen a return on investment. When we write code, the code runs for some milliseconds, and then we have the database query that runs for some milliseconds as well. Using Hasura avoids writing any extra code, so we could save those milliseconds on the server, which will save cost. We can save millions of dollars, or thousands of dollars at least.

My experience with pricing, setup cost, and licensing is that since it is very fast, the pricing is less. It takes less time, which is an advantage to the organization.

Before choosing Hasura, I evaluated PostgreSQL DB, which we connected directly from the code. This required us to write the code, so we opted for Hasura so the productivity would be faster.

If I had to pick just one number, I would say nine because development would be faster, which is expected in any industry. It requires less time for development.

Regarding Hasura's AI capabilities, I think its governance and security are good. Perhaps we could increase those in the future, but since it is in the initial phase, it is quite good with no issues as of now.

The accuracy of Hasura's output is quite good as of now, with no issues with that.

My advice to others looking into using Hasura is to directly use it since it is a very good application with high performance and scalability.

Since Hasura is quite a good product, I have also suggested using it in different products in the current organization. I hope for the best. I would rate this review a 9 overall.

Private Cloud

Amazon Web Services (AWS)

My main use case for Hasura is for a backend that is made on Hasura.

For one healthcare project, we have used Hasura as a full back end, and we have the database and all those things inside Hasura. We have created the APIs using GraphQL inside Hasura and the actions, triggers, and cron jobs, all using Hasura.

We just need to define some query in the cron job, which we need to run on a particular schedule that we define. That can be defined in cron job and scheduled triggers according to our business logic use case need.

The main usage where I find Hasura useful is the faster API development. With GraphQL, you just need to check tick boxes and that's it. In nearly 10 to 30 seconds, an API is created, and you can easily deploy it.

The instance management is very easy for an application. The first time when you set up Hasura, you need to properly check the DB configuration connections, and the rest is easy. If you want some custom business logic, you can define that in actions, cron jobs, triggers, or whatever you want to create on Hasura.

The best feature which I liked in Hasura is the cron job and scheduled triggers. Apart from that, actions is also a good feature.

Earlier, we took around maybe two days to create some APIs and set up DB and other things. In Hasura we can create tables and relationships and APIs in the end. DB creation, configuration, and deletion of rows are very easy in Hasura. Earlier, where two days were taken, now we can only do it in half to one day at max.

In development effort, very much time is saved, and the execution is fast.

Hasura can be improved in a way such that the setup process could be improved, and the loggings and Hasura logs could be improved. Apart from that, there are some restrictions while defining actions or while using GraphQL. We cannot do certain particular queries while writing GraphQL which we can easily do in SQL while writing a Node API. Those things can be improved in Hasura.

There is always a scope for improvement.

I have been using Hasura for two plus years.

Hasura is stable.

Hasura's scalability is good. Production-wise, it is good.

Customer support is fine.

Previously, I was using Node and Express.js. For faster development, I switched to Hasura.

The pricing is fine, and the licensing and setup costs are fine.

Hasura is an overall good product. If you are using Node.js language, consider switching to Hasura. I would rate this product 8.5 out of 10.

On-premises

Other

Hasura was my main tool and platform for exposing all of our APIs for our insights page. Everything on our insights webpage was our analytics products from Atency, and that is where we were using Hasura for data access control, having security classes, and controlling the data via APIs.

In general, everything related to APIs was via Hasura in my previous company. We had our webpage with reports via Power BI, but for all our API-related components, it was everything via Hasura.

Hasura offers quite user-friendly features. It is easy to adapt, especially since it is GraphQL, which is similar to SQL. It provides a nice interface to build different APIs, and one feature I really appreciated was access control. For example, we had many customers with one single table of data, but data access control prevented one customer from seeing another customer's data.

Access control was vital for our product-based company with more than 100 customers to prevent data breaches and leaks, which are security issues tied to customer trust. To maintain everything and the trust of our customers, it was crucial to have good data access control. Via this API access control, it was easy; we just added company-level access control to Hasura, filtering based on different customers, ensuring each customer received only their data.

Hasura positively impacted our organization through useful access control, allowing us to directly obtain data without extra layers of access control processes, which increased efficiency and speed.

Regarding limitations, we were using the free version, and perhaps the paid version offers more features. The free version had limitations that made me wish for the paid version. Additionally, GraphQL can be slow and has limitations compared to SQL; extremely complex SQL queries are not possible directly in GraphQL, requiring dependence on sources such as Postgres for complex queries.

Hasura could improve by allowing us to build complex queries within it instead of depending on source databases, which might affect response speed. However, I understand why it is structured this way.

I have been working in my current field for eight to nine years.

I started with the company while Hasura was already in use, so I did not experience a replacement scenario but began using it as a new solution.

My experience while working with it was quite satisfactory.

For others considering Hasura, its effectiveness varies depending on the company size and data amount. For medium-scale or startup companies, it is an excellent option since it is free, but it may not handle immense data for huge companies. I would rate Hasura as a seven out of ten based on my experience because it has some limitations, and I would have preferred more features, such as building complex queries, which are not possible in Hasura.

Not on a public cloud.

Other

My main use case for Hasura is in a web application, specifically for data management.

Hasura offers fast prototyping, allowing me to have an instance and an API set up with Docker Compose in five minutes. The migration tools are particularly valuable, with the Docker container providing excellent support.

Hasura has enabled my organization to prototype quickly and have an available API to query within ten minutes when our team was only one and a half people a year ago.

Hasura could improve with better documentation because I have not always known where to look for certain issues I have encountered. The CLI commands could provide better feedback when something fails.

Practical examples in the documentation would be a significant benefit.

I am concerned about the LTS that Hasura has for the Community version until January 2027, which is a pain point for us and makes us reconsider the project's architecture.

I have been using Hasura for one year.

In the development environment on our local machines, some queries can take eight, nine, or ten seconds to respond, which I do not fully understand. However, in the deployed environment there is no problem.

We are not at that phase of the project regarding Hasura's scalability.

I have not experienced issues with Hasura's customer support.

I have not used a different solution before Hasura.

We use Hasura because it is a quick way to prototype. The GraphQL API is a benefit that we were not accustomed to using, but it works well for us given our business logic.

While we are not at that stage of the project regarding development times or costs, I will point to the prototyping speed that Hasura allows. With table definitions from databases and Postgres tables, Hasura lets you have an application and an API up and running in no time.

Hasura was a recommendation because other projects within our company used it. We needed a way to get started quickly, and Hasura provided exactly that.

One feature I have started trying out is Hasura Actions, which may not fit our project perfectly, but I think they are powerful.

I would advise others considering using Hasura to have version control over their migrations because we do not have it, which I know goes against what Hasura proposes, and it is difficult. Updating anything related to the metadata, migrations, or Postgres tables is challenging because you have to tear everything down and bring it back up, and considerable time is lost. It is important to have that folder versioned.

Custom SQL functions in Postgres are very useful for us because we were coming from a migration and needed to access data referenced in other tables. Those functions have worked well for us.

I give Hasura an eight rating because at one point in the project it helped us move very fast. However, given our architecture, it is becoming a bottleneck because we are dealing with authorization topics and roles, and Hasura does not fit perfectly with our architecture. We may need to study a better way to implement it, but that is the current state of the project.

On-premises

Other

My main use case for Hasura is to create endpoints that I can use to create, get, or update endpoints to my database. My database is on-premise, so to protect it from attackers, we hide it and give access only to Hasura with all the connections from the application directed to Hasura, which connects to the database and returns the answers.

A specific example of how I set up Hasura is as follows: first, for any table, I create the table in the database, then I come back to Hasura and reload the schema for the connected database. Once the database is reloaded, I go to the tracking section and track the table that was recently created. After that, once the table is tracked, I go to the GraphQL space and select the table as well as the columns I want, and it will generate the GraphQL query. I give the return type and save this with a particular name, which acts as the endpoint for my application to access that particular table.

In my experience, the best feature Hasura offers is its scalability.

Hasura's scalability stands out for me as we had a development server and a production server, and we needed to set up a user acceptance test server, UAT server. For this, all we had to do was set up a few connections, then copy the metadata and load it back to the UAT servers to get started. The migration from one environment to another was very fast, which was very helpful. Regarding reliability, the SQL server can mostly have many concurrent connections and can have issues, but in such cases, the load falls onto Hasura, and it handles it very well. All SQL errors or messages reach Hasura at the end, so we do not need to go back and check it on the SQL layer.

Hasura has positively impacted my organization as before Hasura, we used to write the GraphQL code and REST APIs for every table. After Hasura, it is just connecting the database to Hasura and then creating a GraphQL query and setting it as an endpoint. That is much easier than the process of writing the REST endpoints at the code level on the backend server. This makes the implementation much easier and many things easier overall.

I have faced some pain points regarding the migration process.

Regarding needed improvements about migration, if a company has a single development server and multiple production servers, this segregation can be done at the database level or at the level of tables migration. This could be improved.

Regarding my main use case with Hasura, the graphical user interface, GUI, the web interface that is offered is particularly very slow if you have a lot of endpoints configured. It is better to use CLI, which is the preferred method for me. All the endpoints are very fast and responsive, as Hasura servers are very fast. The setup does not take a lot of time as it is just one metadata file, and we can recover all of the set endpoints, making backing up and storing everything very easy.

I would like to add that the user interface is particularly very slow and sometimes overwhelmingly slow. This is not about the response of the endpoints, but rather the user interface itself.

I have been using Hasura for one year.

In my experience, Hasura is stable and has been reliable day-to-day; I have never faced any downtime.

Hasura's scalability has handled growth or changes in my workloads very well.

I have not needed to reach out for help, as I never reached out for any support.

I did not use any other solution before Hasura; I am a fresher.

Hasura's integration capabilities with other tools or services I use are easier to integrate. It is a pretty easy setup; once we have a subscription, we can plug in the database credentials and then get started with creating the GraphQL. This is a much easier process compared to manually creating those endpoints at a backend.

Hasura saves a lot of time for my team; just for a single table implementation, it would have taken one or two days, but now it just comes down to one or two minutes.

Hasura's monitoring and logging capabilities are sufficient for my needs; we can integrate Prometheus and Grafana for monitoring. I collected all the logs and metrics from Prometheus and connected them to the Grafana dashboard, from where I can visualize all the issues that are occurring.

The experience with pricing, setup cost, and licensing for Hasura was handled by my organization.

I have seen a return on investment with Hasura, as the time saved is significant at 70% less time dealing with database queries and REST APIs for development, which saved a lot of people's time.

My advice to others looking into using Hasura is to look into it if you want to reduce your backend APIs, as that can be drastically reduced.

Based on my experience so far, I do not think there are any other improvements that Hasura needs. I would rate this product an 8 out of 10.

Public Cloud

Microsoft Azure