Hasura Cloud Enterprise

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.

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.

My main use case for Hasura involves dealing with multiple source systems, where we had to create a bunch of repetitive backend work, leading to many APIs that needed to be built. Hasura made development easier because it was useful without wasting time building basic APIs over and over again; instead of creating the controller, service, repository, and DTOs manually, along with filtering and sorting, Hasura has made the work straightforward.

A quick specific example of a project where Hasura helped me save time is our auto-renewal system, which we built in a recent renewal job. Without Hasura, after processing, a backend would need to expose an API endpoint such as /renewals, requiring us to manually build the DTOs, maintain multiple endpoints, support frontend changes, and handle real-time updates separately using WebSockets. With Hasura, the work became straightforward; the .NET jobs update the database, and it automatically exposes the updated data with no need for backend changes, also aiding in the real-time dashboard updates.

The feature that had the most impact on my work was real-time data combined with eliminating the backend API development; that combination greatly sped up building the systems. This mattered most because our system needs to process tasks such as renewal processing, background jobs, and orchestration workflows. Using the AG Grid table was particularly useful, as we have to show renewals that are pending, processing, completed, or failed. Without Hasura, we would have had to create several REST endpoints, polling APIs, and manage WebSockets, along with manual filtering APIs. Hasura has changed our approach by handling API generation, GraphQL queries, subscriptions, and filtering, allowing the frontend to no longer wait for backend APIs to make changes.

Hasura reduced backend boilerplate and enabled real-time operational dashboards by automatically exposing database changes through GraphQL subscriptions, allowing our services to focus only on business processing while Hasura handled API generation and live data.

In my opinion, the best features Hasura offers are the auto-generated GraphQL APIs, as it has auto-generated GraphQL APIs and instantly provides queries, mutations, and real-time subscriptions. The frontend can fetch whatever data it needs, instead of fetching huge payloads. Since we used AG Grid for showing huge datasets in a table, the filtering and querying capabilities were very powerful, and the role-based security implementation with Hasura is also commendable.

Hasura positively impacted my organization by facilitating fast development; we saved a lot of time in development. I can estimate that we saved significant time; we do not need to manually create all the GraphQL queries or API generations. I can say we could build an API within hours instead of taking days.

The time saved reflects a significant return on investment.

Regarding needed improvements, the complex business logic, nested joins, and over-fetching need to be addressed. Additionally, Hasura needs query limits, caching, monitoring, and better handling of database coupling.

I have been using Hasura for three years.

In my experience, Hasura is stable.

Hasura's scalability is good, but it heavily depends on proper design; while Hasura can scale horizontally, scalability mostly relies on database design, caching, and subscription management.

I have not reached out to customer support, and we have not faced that many issues.

I did not previously use a different solution with this company.

Before choosing Hasura, we evaluated other options; we traditionally used REST APIs by building backend services in ASP.NET Web API, along with using Node.js, Express, and Java Spring Boot. The old approach created too much boilerplate, requiring a controller, service, repository, and mapping validations for every table and making our frontend heavily dependent on the backend.

My advice to others looking into using Hasura is that if they have an automated system such as auto-renewal, or multiple source systems to deal with while using GraphQL, then I would suggest going with Hasura. I rate this product a 9.

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.

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.

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.

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 have been using Hasura for about one to one and a half years.

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.

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.