May 2024 Summaries

Lumanu, an influencer marketing platform, has significantly improved its development velocity and latency by adopting Hasura as its GraphQL API engine. The company transitioned from a Clojure-based microservices architecture to a single GraphQL API built around Hasura, resulting in an 8x speed up in feature development cycles and a 10-15x reduction in app latency. Hasura's self-serve composability and API standardization have also empowered Lumanu's teams, allowing them to focus on innovation and growth within the influencer marketing sector.

This blog discusses how Hasura and Apollo GraphQL can work together effectively in creating high-quality subgraphs for GraphQL federation. While both technologies coexist in the GraphQL ecosystem, they have different approaches when it comes to developing production-grade APIs. Hasura is a data API platform that helps build GraphQL subgraphs on various data sources and automates the creation of scalable APIs. Apollo provides tools for building apps with GraphQL and has tooling for creating and running a federated GraphQL API. The integration of these two technologies can accelerate the journey towards GraphQL federation, particularly within enterprise environments.

Building a GraphQL API server in Java involves several steps and considerations. Here's an overview of the process: 1. Define the scope of your application, including features like persistence, flexibility, efficiency, and modernity. 2. Choose appropriate tools and frameworks, such as Spring Boot, Spring for GraphQL, a database, and a data model. 3. Create a GraphQL schema file that defines the structure and relationships of your data. You can use tools like Spring Initializr to bootstrap your project and create the schema file. 4. Develop Java model classes that represent the structure of your data in your Java code. These classes define properties and relationships that correspond to the fields and types in your GraphQL schema. 5. Implement controller classes, which are Java classes annotated with @Controller. They contain methods that handle incoming requests and map them to the appropriate resolver/data-fetcher methods. 6. Write resolver/data-fetcher methods that mediate interactions with the database and return data to the client. These methods may involve writing SQL statements, using ORM tools, or leveraging database access frameworks like Spring Data JDBC. They handle data validation, business logic, and error handling. 7. Consider implementing the data loader pattern to optimize database interactions by reducing the number of SQL queries sent to the database. This improves performance and reduces network chatter. 8. Explore alternatives to building a GraphQL API server from scratch, such as using a GraphQL to SQL compiler like Hasura or acquiring an existing GraphQL API solution instead of building one. 9. Embrace principles like simplicity over complexity, constraints over code, data over algorithms, and people over process to guide you in designing efficient and maintainable software solutions.

Hasura has released a native data connector for MongoDB, enabling users to rapidly author APIs for data stored in MongoDB using Hasura's Data Delivery Network (DDN). The DDN represents a new framework for developing, operating, and maintaining APIs as domain and data consumption requirements evolve. Key elements of a great API on MongoDB include documentation, type safety, versioning, pagination, filtering, sorting, querying nested data, joins, authorization, performance, and enabling MongoDB features such as Vector Search and Time Series. Hasura DDN streamlines the creation of APIs for MongoDB by abstracting complexities and offering a more structured approach through its intuitive domain-first modeling framework. The framework accelerates the development and scaling of MongoDB APIs, providing tools that streamline schema generation, enhance documentation, ensure type safety, facilitate complex queries while managing API evolution and maintaining robust security measures.

The guide explores the return on investment (ROI) of adopting GraphQL, emphasizing the need for both tactical and strategic benefits to justify its implementation. Tactical benefits often involve reducing inefficiencies and costs, such as simplifying data aggregation for frontend teams, while strategic benefits offer competitive advantages, like accelerating innovation and improving user experiences. It discusses how GraphQL can replace traditional API tools, enhance developer productivity, and offer a federated, self-documenting API model that eases collaboration. The text outlines a blueprint for building an ROI model, stressing the importance of clearly defined goals, architecture planning, and iterative testing. It also presents case studies from a Fortune 10 bank and a Fortune 100 communications giant, showcasing successful GraphQL adoption strategies and the measurable gains achieved. Additionally, it highlights emerging GraphQL trends, such as the shift back to backend concerns and diverse subgraph tooling, which impact the costs and benefits of adoption. The guide concludes by acknowledging the inherent complexity and variability in ROI modeling, recommending experimentation and adaptation to specific organizational contexts.