April 2024 Summaries

The Hasura Data Delivery Network (DDN) simplifies backend development by offering unparalleled composability across data sources through its supergraph architecture. With the support of TypeScript functions on Hasura DDN, developers can focus on writing sync or async functions that return some data, and Hasura will do the code introspection and generate all the configurations needed for a production-ready GraphQL API. This includes all configurations needed for the GraphQL schema, observability readiness, and more advanced configurations. The supergraph architecture of Hasura DDN allows developers to define relationships between different data sources, and now with their code as well.

In this blog post, the author discusses the launch of Hasura v3 in beta and its focus on consolidating data access through data connectors. The development history of Hasura is outlined, from its initial focus on PostgreSQL to the introduction of GraphQL Data Connectors (GDC) in v2 for various new data sources. The author then introduces Native Data Connectors (NDC), which are not tied to Hasura and can be used with other clients or transport mechanisms. NDC is designed to expose the native capabilities of target data sources, pushing down execution as much as possible and imposing minimal structure from the protocol itself. The benefits of NDC include progressive enhancement, support for non-cloud-native data sources, resource allocation and execution mobility, independent configuration, language independence for developers, improved build times, separation of concerns, packaging of database drivers, and adapter connectors. The author also mentions plans to build more connectors, improve development tooling, research new capabilities, and create better learning resources for connector authors.

Hasura introduces multi-region database routing for its Data Delivery Network (DDN), offering instant GraphQL APIs on various data sources. This feature enables seamless operation across boundaries while minimizing latency, ensuring faster API responses and improved user experience. Built-in support for multi-region routing is initially available for PostgreSQL family databases, with plans to extend it to other connectors in the future.

The article discusses when to choose GraphQL over REST and why. It emphasizes that understanding the trade-offs is crucial in making this decision. The first use case mentioned is the client-side N+1 problem, where multiple HTTP calls are made from the client to the server. In such cases, GraphQL can be an instant win as it allows for querying deeply nested data and fetching multiple independent entities in a single HTTP request. The second use case is the server-side N+1 problem or API integration, where data needs to be fetched from multiple sources on the backend. In this scenario, GraphQL can make queries more efficient by using Dataloader patterns/batching and implementing a query planner for high performance. Additionally, GraphQL offers benefits such as flexible APIs with consistency, self-documentation, and predictability due to its schema and type system. In summary, GraphQL is often the better choice over REST for solving client-side N+1 problems and can be advantageous in server-side scenarios depending on the backend implementation and use of a query planner.

The GraphQL maturity model outlines the stages of a GraphQL adoption journey. It begins with stage 1, where a single subgraph is built, and progresses to stage 5, which involves building a graph of graphs (supergraph) via GraphQL federation. This model helps developers anticipate challenges in later stages and fine-tune their current efforts based on others' experiences. The key focus areas change from a single team's concern to potentially affecting the entire engineering organization as the maturity level increases. The model also highlights the growing complexity of the federated GraphQL API, with sample queries demonstrating the art of possible enabled by the API at each stage.

Toronto-based engineering firm Tactable has integrated Hasura into its core toolset due to the platform's powerful GraphQL capabilities and overall value in backend development. The company leverages Hasura for tasks such as managing database migrations, seeding large databases, changing schema, and efficiently creating REST endpoints. By using Hasura, Tactable has been able to streamline its development processes and eliminate the need to build controllers for every backend feature. Additionally, Hasura's role-based access control (RBAC) and scalability have enabled the firm to connect large data sets and manage complex tasks efficiently.

GraphQL is transforming data interaction by enabling developers to query disparate data sources through a unified API layer, exemplified by the creation of a supergraph using Hasura and AWS AppSync. This approach allows for seamless integration and querying of data from PostgreSQL and Amazon DynamoDB, creating a cohesive data graph that simplifies access and management. Hasura connects to PostgreSQL to auto-generate GraphQL APIs with advanced querying capabilities, while AWS AppSync facilitates the creation of a GraphQL API for DynamoDB. These individual subgraphs are then federated into a supergraph, allowing for comprehensive queries across both databases, as demonstrated in an e-commerce scenario where product and inventory data are queried together. Embracing supergraph architecture is vital for organizations seeking to unify and scale their data landscape efficiently, promoting a modular and scalable infrastructure by reducing the complexity of handling multiple APIs.

Hasura Data Delivery Network (DDN) introduces preview deployments for APIs, similar to frontend frameworks like Vercel and Netlify. This feature increases developer productivity, collaboration, and confidence in deployments through zero-downtime production deploys and rollbacks. Preview deployments enable developers to get faster feedback loops by making debugging and testing easier and facilitating safe isolated testing without affecting the live version for users. Hasura DDN's preview deployments are available across all plans, including the free plan. The feature is powered by Hasura v3 GraphQL Engine, which separates build time from run time, enabling new "builds" or "deployments" for GraphQL APIs without affecting the version currently running in production.

Hasura Data Delivery Network (DDN) is a solution that enables developers to build and scale applications effortlessly by leveraging the power of ClickHouse, an advanced real-time analytics database. With DDN, developers can create a supergraph, a unified data API layer that simplifies microservices, allowing them to focus on application development. Hasura DDN accelerates development by providing reusable data connections and eliminating the need for teams to build and operate microservices for data accessibility. It offers benefits such as composable APIs, supergraph federation, performance optimization, easy configuration, connector ecosystem, operational guarantees without operational work, reliability, global performance, instant autoscaling, and deep observability. ClickHouse is a powerful open-source columnar database designed for speed and efficiency in processing large volumes of data, making it suitable for real-time analytics and handling time-series data or log data. It offers features like columnar storage model, real-time query processing, massive scalability, vectorized query execution, data compression, SQL support, high availability and fault tolerance, materialized views, and projections.

In this blog post, Hasura introduces its latest observability powerhouse - GraphQL operation tracing for its Data Delivery Network (DDN). This feature enables end-to-end distributed tracing to observe the journey of a request from the client to the database and back. It helps in quick debugging and system optimization as users build their supergraph. Hasura DDN's tracing capabilities provide real-time insights, allowing users to visualize all components on their system, from the client, Hasura server, data connectors, and to their database. The tracing feature is extremely powerful with its ability to identify bottlenecks or latencies in various components or services in a system.

The future of API is composability, as highlighted by Hasura Data Delivery Network (DDN) in beta. API composability refers to the flexibility of combining and reusing APIs or their endpoints to construct more elaborate services or applications. This concept is particularly relevant in microservice architectures and serverless computing, where services are designed to fulfill specific functions or a limited set of closely related tasks. Enhanced API composability elevates the level of self-serve composition capabilities while concurrently diminishing the need for manual API aggregation and composition. The supergraph architecture pattern offers an elegant approach to managing and orchestrating APIs, particularly in the context of GraphQL APIs. Aimed at backend engineers grappling with the complexities of data access and API integration, a supergraph serves as a federated operating model that enables teams to construct a self-serve platform for seamless data access and API composition. The true value of a supergraph lies in its inherent composability, which significantly diminishes the necessity for manual intervention in data integration and API orchestration.

Hasura has announced the beta release of its Data Delivery Network (DDN), an incredibly powerful API platform that delivers unmatched on-demand data composability in an API. The new platform aims to fundamentally transform the economics of building and scaling APIs on data, staying true to their mission of making APIs free for users with domains. Hasura DDN is built on a supergraph architecture, which connects all data sources via a semantic graph exposed through a single composable endpoint. The platform offers intuitive domain-centric modeling framework, unparalleled on-demand composability, blazing-fast performance for any query, rapid CI/CD with new build system and build-time validation checks, enhanced observability and API analytics, brand new console with better discovery and onboarding, open and extensible connectors ecosystem, global edge network for performance and reliability at any scale, and a disruptive model-based pricing model. The free tier is now available, with more features planned to be released throughout April.

Hasura has introduced the beta version of its Data Delivery Network (DDN) and a new model-based pricing structure. The active model-based pricing aligns costs with the value received from the API platform, charging for constructing the bridge rather than using it. Customers will only be billed for active models that experience more than a certain threshold of requests. This approach provides predictable costs based on an application's resource demands and can significantly reduce overall bills. The new pricing model is available in three tiers: Free, Base (coming soon), and Advanced (coming soon).

Hasura has announced the beta launch of its Data Delivery Network (DDN), built on the Hasura v3 GraphQL engine. The two core guiding principles behind Hasura DDN are that APIs should be free if you have the domain, and the future needs composable APIs. Key features include automatic API contracts derived from data or code, frictionless CI/CD, and scalability without cost impact. The launch month will introduce remarkable Hasura DDN features across three main fronts: no effort to author, build, or scale APIs.