Best of GraphQL — 2025

1. 1
   Article

   freeCodeCamp·1y

   Learn API Fundamentals and Architecture – A Beginner-Friendly Guide

   APIs (Application Programming Interfaces) are essential tools that enable communication between different software systems. This guide covers the fundamentals of APIs, including their types (Open, Partner, Internal, Composite) and various architectures (REST, SOAP, GraphQL, gRPC). APIs streamline development by facilitating data exchange and integrating external functionalities securely and efficiently. Understanding these concepts helps developers choose the right API architecture based on performance, scalability, ease of use, and security needs.

   458

   5
2. 2
   Article

   Datadog·16w

   How microservice architectures have shaped the usage of database technologies

   Microservices have transformed database usage from monolithic, single-database architectures to distributed systems where organizations run multiple database technologies simultaneously. Analysis of 2.5 million services shows over half of organizations now use both SQL and NoSQL databases side by side, with many adopting 3+ different database technologies. This shift enables teams to choose the right tool for each service but introduces new challenges: fragmented schemas require data integration layers like GraphQL, analytics demands OLAP systems like Snowflake, and service communication relies heavily on message queues like Kafka and RabbitMQ for asynchronous decoupling.

   155

   1
3. 3
   Article

   System Design Codex·49w

   Key API Design Considerations

   A well-designed API is crucial for predictability, consistency, and scalability. Key considerations include defining clear interfaces, choosing the appropriate API paradigm (REST, GraphQL, or gRPC), modeling relationships effectively, implementing versioning strategies, and using rate limiting to manage requests. Treating APIs as products enhances their usability and maintainability.

   135

   2
4. 4
   Article

   ByteByteGo·45w

   How Netflix Runs on Java?

   Netflix operates its massive streaming platform primarily on Java, utilizing a federated GraphQL architecture with Spring Boot microservices. The company migrated from Java 8 to JDK 21+, adopting virtual threads for improved concurrency and ZGC garbage collector for near-zero pause times. Their backend consists of around 3000 Spring Boot services communicating via gRPC, with GraphQL serving as the client-facing API layer. Netflix moved away from reactive programming (RxJava) in favor of virtual threads and structured concurrency, while building custom tooling to maintain their Spring Boot Netflix stack with company-specific integrations for security, observability, and service mesh functionality.

   124

   1
5. 5
   Video

   ForrestKnight·49w

   Netflix is Built on Java

   Netflix heavily relies on Java for its backend operations, utilizing it for both streaming services and studio applications. While front-end technologies vary, the backend is unified under Java, featuring a microservices architecture supported by GraphQL and gRPC. Netflix transitioned from Java 8 to newer versions like JDK17 and JDK23, improving performance with upgraded garbage collection and exploring virtual threads. Their backend involves distributed data stores and global streaming capabilities. The integration of Spring Boot and active collaboration on its development highlights Netflix's substantial influence on the Java ecosystem.

   110

   12
6. 6
   Article

   System Design Codex·1y

   Load Balancer, Gateway, BFF & GraphQL: The Squad Handling API Calls

   Modern systems use architectural components like Load Balancers, API Gateways, Backend-For-Frontends (BFFs), and GraphQL to ensure efficient, secure, and customized data delivery. Load Balancers distribute incoming requests across multiple servers for high availability. API Gateways coordinate requests between clients and microservices, centralizing concerns such as authentication and rate limiting. BFFs tailor API responses to specific frontend needs, preventing over-fetching or under-fetching of data. GraphQL allows clients to request precise data, preventing over-fetching, and supports real-time updates. These components work together to enhance performance, scalability, and flexibility in API handling.

   105

   1
7. 7
   Article

   Community Picks·41w

   facebook/relay: Relay is a JavaScript framework for building data-driven React applications.

   Relay is a JavaScript framework by Facebook for building data-driven React applications using GraphQL. It provides declarative data fetching, query colocation with components, and automatic handling of mutations with optimistic updates. The framework aggregates queries into efficient network requests and offers automatic data consistency and error handling.

   100

   1
8. 8
   Article

   ByteByteGo·1y

   EP155: The Shopify Tech Stack

   Shopify utilizes a tech stack that includes Ruby, TypeScript, Lua, React, Ruby on Rails, Nginx, OpenResty, GraphQL, MySQL, Redis, and Memcached. Their DevOps tools include GitHub, Docker, Kubernetes, GKE, BuildKite, and ShipIt, which has been made open source. This infrastructure supports over 600,000 merchants and handles 80,000 requests per second during peak traffic.

   95

   3
9. 9
   Article

   ByteByteGo·38w

   EP172: Top 5 common ways to improve API performance

   Covers five key techniques for improving API performance: result pagination for large datasets, asynchronous logging to reduce I/O overhead, data caching with solutions like Redis, payload compression using gzip, and connection pooling for database efficiency. Also compares REST vs GraphQL architectures, explains the differences between JWT tokens and API keys for authentication, outlines AWS tech stack components across nine layers, and describes five database index data structures that optimize query performance.

   84
10. 10
    Video

    Community Picks·1y

    gRPC vs REST vs GraphQL: Comparison & Performance

    Comparing REST API, GraphQL, and gRPC, the post explores their deployment on a Kubernetes cluster, measuring latency, CPU, memory, and network usage. It highlights the strengths and weaknesses of each, showing gRPC excelled under high load with the lowest resource usage, while REST API performed reliably with lower latency under moderate load. GraphQL struggled at higher requests per second due to its query engine overhead.

    81
11. 11
    Video

    YouTube·31w

    How to Design APIs Like a Senior Engineer (REST, GraphQL, Auth, Security)

    A comprehensive guide covering advanced API design principles that distinguish senior engineers from junior developers. Explores REST, GraphQL, and gRPC architectures, application protocols (HTTP, WebSockets, AMQP), transport layer protocols (TCP/UDP), and authentication methods including OAuth2 and JWT tokens. Covers practical aspects like resource modeling, status codes, error handling, filtering, pagination, and security best practices for building scalable, maintainable APIs.

    80

    1
12. 12
    Article

    WunderGraph·45w

    We accidentally built a backend framework for LLMs

    WunderGraph accidentally created a backend framework for LLMs while solving API orchestration challenges. Their Cosmo Plugins system uses LLMs to generate proxy code that connects non-GraphQL services to a unified Supergraph, enabling companies to build modular monoliths or microservices without rewriting existing REST APIs. The framework leverages GraphQL Federation to create a single API entry point from multiple services, reducing complexity and API calls while maintaining deployment flexibility.

    78

    1
13. 13
    Video

    HuXn WebDev·48w

    GraphQL Super Simplified (Course)

    GraphQL is a querying language for APIs that allows apps to request specific data, addressing issues like overfetching and underfetching prevalent in REST APIs. The post outlines the setup of a GraphQL server using Node.js and Apollo Server, focusing on type definitions, resolvers, relationships, and mutations for handling data effectively.

    69
14. 14
    Article

    Platformatic·32w

    Massimo: Type-Safe API Client generator

    Massimo is a type-safe API client generator that evolved from @platformatic/client, now supporting both OpenAPI and GraphQL schemas. It offers dual architecture with both code generation (massimo-cli) for build-time client creation and runtime library (massimo) for dynamic client generation. The tool generates TypeScript-first clients for both server-side (using Undici) and frontend (using native fetch) environments, with enterprise-grade features including authentication, validation, and telemetry support.

    58

    1
15. 15
    Video

    ByteByteGo·50w

    System Design Was HARD - Until You Knew the Trade-Offs, Part 2

    System design involves making trade-offs in various aspects such as scaling, API design, and processing methods. Vertical scaling is simpler but limited, while horizontal scaling offers more growth but requires complexity in distribution. REST APIs are useful for simple operations, but GraphQL provides flexibility for more complex data needs. Choosing between synchronous and asynchronous processing depends on user experience and complexity considerations.

    57
16. 16
    Article

    Baeldung·48w

    Introduction to RESTHeart

    RESTHeart is a Java-based framework designed to build HTTP APIs on top of MongoDB, automatically exposing collections as REST and GraphQL endpoints. It offers CRUD operations, role-based access, and authentication out of the box with minimal setup, providing a zero-code solution. This tutorial guides on running RESTHeart locally or via Docker, setting up authentication, and performing CRUD operations both through REST and GraphQL APIs.

    56

    2
17. 17
    Article

    Netflix TechBlog·25w

    Behind the Streams: Real-Time Recommendations for Live Events Part 3

    Netflix engineered a real-time recommendation system to handle live event streaming at massive scale, serving over 100 million concurrent devices. The solution uses a two-phase approach: prefetching recommendations and metadata during natural browsing patterns before events, then broadcasting low-cardinality state updates via WebSocket when events start. This architecture solves the thundering herd problem by distributing load over time and minimizing real-time compute requirements. The system leverages GraphQL schemas, Apache Kafka, and a two-tier pub/sub architecture to deliver updates in under a minute during peak load, while adaptive traffic prioritization and cache jitter prevent unexpected traffic spikes.

    46
18. 18
    Article

    Prismic·18w

    Best Headless CMS for Developers in 2026

    Headless CMSs offer developers flexibility, control, and scalability by separating backend from frontend. The top five platforms in 2026 are Prismic (visual page building with AI tools), Sanity (structured content with automation), Contentful (enterprise digital experience platform), Strapi (open-source with plugin ecosystem), and Hygraph (GraphQL-native). Key selection factors include pricing models, API type (REST vs GraphQL), integration ecosystem, and team workflow needs. Modern platforms increasingly include AI features for content generation, translation, and optimization.

    43

    9
19. 19
    Article

    monday Engineering·26w

    Unmasking a hidden singleton

    A load test on monday.com's AI Reports feature revealed a critical race condition caused by a hidden singleton pattern. When multiple users simultaneously generated reports, a WorkdocsAPIService registered as a singleton shared mutable state across concurrent requests, causing workdoc IDs to override each other and trigger 400 errors. The bug remained undetected in production due to low adoption rates and high pod count, which minimized collision probability. The investigation traced through multiple hypotheses before discovering the singleton registration issue, highlighting the importance of load testing, end-to-end concurrent testing, and preferring stateless class designs in asynchronous environments.

    40
20. 20
    Article

    Awesome Go·1y

    Finly — Building a Real-Time Notification System in Go with PostgreSQL

    Learn to implement real-time notifications in Go using PostgreSQL's PGNotify for efficient Pub/Sub messaging. The setup ensures instant updates and toast alerts in Finly's notification center. The guide covers database triggers, PGX for listening to notifications, exposing subscriptions via GraphQL, and frontend integration with Apollo Client for seamless user updates.

    38
21. 21
    Article

    marmelab·28w

    Do you need a Backend For Frontend?

    The Backend-for-Frontend (BFF) pattern addresses common issues in multi-client applications where frontend teams struggle with API complexity and performance problems. A BFF acts as a dedicated translation layer between frontends and backend services, aggregating data and handling client-specific logic. While it can dramatically improve development velocity and mobile performance, it's not suitable for simple applications or small teams due to increased operational complexity.

    33
22. 22
    Article

    marmelab·24w

    From GraphQL to Zod: Simplifying Arte's API Architecture

    Marmelab helped Arte migrate from a complex GraphQL-based backend-for-frontend to a simpler REST API architecture using Zod for runtime type validation. The original GraphQL layer, implemented in 2017 to aggregate data across multiple platforms, had evolved into a REST API that internally used GraphQL.js, creating maintenance overhead and onboarding friction. By prototyping with the most complex endpoint first, the team discovered Zod could provide the same runtime type safety as GraphQL schemas while reducing architectural complexity. Key challenges included handling runtime validation, JSON serialization gotchas with undefined values, and filtering extra properties. Advanced patterns like using merge() instead of intersection() for discriminated unions proved essential. The migration reduced cognitive load while maintaining type safety, demonstrating that architectural decisions should evolve with project needs.

    27

    4
23. 23
    Article

    WunderGraph·18w

    TypeScript Plugin Support for Cosmo Connect

    Cosmo Connect now supports TypeScript router plugins, enabling developers to extend GraphQL federation routers with custom logic written in TypeScript without deploying separate services. Previously limited to Go, this feature makes plugin development accessible to TypeScript-focused teams. Plugins run inside the router, are published through Cosmo Cloud, and participate in schema checks like subgraphs. The workflow involves initializing a plugin via CLI, generating protobuf definitions from GraphQL schemas, implementing RPC handlers in TypeScript, building the plugin artifact, and publishing to Cosmo Cloud where routers automatically pull updates. This approach is particularly useful for wrapping legacy REST APIs or exposing small pieces of logic without the operational overhead of deploying full subgraph services.

    12
24. 24
    Article

    WunderGraph·46w

    API Orchestration with LLMs: Integrate APIs with a single prompt

    The post discusses the challenges of declarative API orchestration using tools like Apollo Connectors and introduces WunderGraph's new approach with gRPC Plugins. Leveraging LLMs, this solution simplifies API integration by automating code generation and addressing issues like the N+1 problem, testability, and debugging. By choosing Hashicorp's go-plugin library and focusing on a scalable, low-overhead development experience, it promotes ease of use, allowing plugins in multiple programming languages.

    12
25. 25
    Article

    Supabase·47w

    Simplifying back-end complexity with Supabase Data APIs

    Supabase simplifies backend complexity by auto-generating secure REST and GraphQL APIs for Postgres databases, reducing infrastructure overhead and maintenance. It exposes APIs instantly for tables, views, and procedures without requiring custom CRUD endpoints. Supabase enables easy integration with features like pagination, filtering, and edge functions, enhancing flexibility and control, while row-level security and authentication ensure robust protection.

    11