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.