This article outlines practical software design principles—layered architecture, single responsibility, data redundancy, security, concurrency, and API design—derived from real‑world financial platform projects, showing how concrete rules help avoid coupling, data loss, and performance pitfalls.
The article critiques returning vague third‑party API error messages, explains why swallowing exceptions and omitting stack traces make debugging hard, and advises providing user‑friendly messages and proper logging to improve reliability and maintainability of backend services.
Effective API design is crucial for microservice architectures, reducing communication overhead, preventing API decay, and ensuring scalability; this article outlines common pitfalls, core design principles such as simplicity, focus, extensibility, compatibility, thorough testing, and documentation to help developers build robust, maintainable services.
The discussion compares two API response designs—always returning an empty array for field B versus omitting B when it has no data—and evaluates which approach provides clearer contracts and easier handling for front‑end developers.
This article explains why REST APIs have become cumbersome, introduces GraphQL as a more flexible alternative, and details its benefits, execution model, schema and type system, as well as practical server and client implementation options.
This article examines the limitations of traditional REST APIs, explains how GraphQL offers a more flexible, efficient, and declarative approach to data fetching, outlines its core concepts, schema design, type system, and deployment architectures, and provides guidance on integrating GraphQL into existing backend and frontend ecosystems.
This article examines the four major API architectural styles—RPC, SOAP, REST, and GraphQL—explaining how each works, their strengths and weaknesses, and the scenarios where they shine, helping developers choose the best fit for their projects.
This article compares the main HTTP API design styles—REST, RPC, and GraphQL—explaining their principles, typical code examples, and trade‑offs, and also discusses serialization formats such as protobuf and JSON, helping backend developers choose the most suitable approach.
The article explores practical design principles for microservice architecture, covering core concepts, team and database partitioning, API granularity, domain‑composed services, gateway strategies, shared JAR dependencies, decoupling techniques, and change‑impact analysis to guide robust backend system development.
This article explains how REST’s coarse‑grained, redundant interfaces hinder front‑end efficiency, then introduces GraphQL as a flexible, declarative alternative that automatically adapts to changing data requirements, reduces API proliferation, and streamlines backend‑frontend communication.
The article explains how adding a new enum constant in a downstream library can cause IllegalArgumentException during RPC deserialization, analyzes the underlying JSON serialization mechanism, and recommends avoiding enums in RPC parameters and return values by using strings with documented constraints.
This article explains how to design a consistent JSON response format for micro‑service APIs, introduces a Result wrapper class with status code, message and data, and shows how to use a custom @ResponseResult annotation together with Spring's ResponseBodyAdvice to automatically wrap controller outputs while addressing common pitfalls and optimization opportunities.
The article examines two ways to define Feign interfaces in a microservice architecture—having the service producer define the Feign client (SPI) versus letting the service consumer define it (API)—and compares their constraints, flexibility, dependency management, and impact on development workflow.
This article explains how to design a unified API response format in a Java-based fresh‑food e‑commerce system, covering overall architecture, JSON response schema, status‑code conventions, Result wrapper class, controller refactoring, custom annotations, and interceptor implementation to achieve clean and maintainable backend responses.
The article details vivo Mall’s heterogenous system integration architecture for a consignment model with NetEase Yanxuan, describing platform selection criteria, an API‑gateway‑style design with modular routing, adapters, unified callbacks and configuration, and the integration of product and order centers, while outlining plans for proprietary API standards to lower future integration costs.
This article distills key recommendations from Joshua Bloch’s Effective Java, covering static factory methods, builder patterns, singleton protection, memory management, and API design conventions, providing concise examples and practical guidance to help Java developers write clearer, more efficient, and safer code.
This article explores the pervasive role of APIs in software development, contrasting good and bad designs, outlining empirical design principles, performance classifications, testing strategies, and cultural factors that affect API usability, while offering practical advice for developers to create robust, well‑documented interfaces.
This article explains how to create a consistent JSON response structure for Java backend APIs, covering status‑code conventions, a Result wrapper class, static helper methods, a custom @ResponseResult annotation, response‑body advice, and tips for simplifying controller code and handling exceptions.
Qualitis is a big‑data‑platform‑based data‑quality‑management service that defines, detects, and reports data‑set quality issues, featuring idempotent backend services, load‑balanced high‑availability, Zookeeper‑coordinated process synchronization, thread‑pool throttling, and clearly separated internal and external APIs.
This article surveys a wide range of REST API tools—covering API definition, testing, monitoring, publishing, and centralized management—highlighting their key features, supported languages, integration capabilities, and suitability for teams of different sizes and project requirements.
Effective API design in microservices requires platform independence, reliability, appropriate RESTful maturity, avoiding simple wrappers, ensuring separation of concerns, exhaustive and independent endpoints, proper versioning, consistent naming, and security measures, all of which are detailed alongside practical examples and a comprehensive review checklist.
This article analyzes the shortcomings of the existing RESTful Node BFF service for Qunar's domestic hotel platform—such as data customization difficulty, manual documentation, and redundant fields—and demonstrates how adopting GraphQL can provide precise data fetching, automatic schema documentation, and unified request composition to improve development efficiency and system performance.
This article examines common pitfalls in API design, argues that the consumer of an interface should drive its design, and presents concrete examples and best‑practice recommendations for structuring endpoints, meta data, and choosing appropriate communication protocols.
This article explains the limitations of traditional REST APIs, introduces GraphQL as a flexible alternative, compares their architectures, and outlines how GraphQL’s schema‑driven approach simplifies data fetching, reduces redundancy, and integrates with existing backend services.
This article outlines essential RESTful API design principles, covering clear URL structures, proper use of HTTP verbs, precise status codes, appropriate response formats, and the inclusion of hypermedia links to create intuitive, maintainable, and standards‑compliant web services.
This article explains how static factory methods improve readability, performance, and flexibility compared to public constructors, covering benefits such as named creation, instance reuse, subtype returns, service‑provider frameworks, as well as drawbacks like limited inheritance and discoverability, and offers naming conventions and real‑world Java examples.
This article explains the limitations of traditional REST APIs, introduces GraphQL as a flexible alternative, and details its core concepts, type system, server‑client architectures, deployment options, and popular tools and services for modern backend development.
This article explores the principles and practical guidelines for designing error codes, comparing log‑oriented and external‑facing standards, analyzing numeric versus alphanumeric formats, and presenting recommended structures to improve traceability, memorability, and cross‑team communication in modern backend systems.
This article details the end‑to‑end design, iterative evolution, and technical architecture of an intelligent lending API platform, covering workflow abstraction, service decomposition, security mechanisms, monitoring, and performance optimizations that enable scalable, reliable integration with multiple financial institutions.
Kong’s Insomnia Designer adds a collaborative, spec‑first environment for designing REST and GraphQL APIs, integrates CI/CD, GitOps, and Kubernetes, and embeds Kong gateway policies directly into API specifications, boosting productivity for cloud‑native development.
This article explains essential RESTful API design details—including URL conventions, HTTP verb usage, status‑code precision, proper JSON responses, and HATEOAS linking—to help developers create clear, consistent, and user‑friendly web APIs.
This article explains the best practices for using parameters and query strings in REST API design, covering pagination, parameterization concepts, HTTP methods, headers, caching, and authorization, and provides guidance on choosing the right approach to create efficient, stateless, and scalable APIs.
This article explains the proper use of Java exceptions, distinguishing between checked and unchecked exceptions, showing when to throw them, how to design APIs that avoid misuse, and offering guidelines for documenting and handling exceptions effectively.
The article details the design principles, modular architecture, and engineering optimizations of a backend algorithm platform that uses APIs, micro‑services, and asynchronous processing to enable fast, reliable, and scalable online algorithm services, including recall, ranking, metadata, feature reporting, and A/B testing.
This article provides comprehensive API design guidelines covering routing naming conventions, request methods, parameter structures, security measures, response formats, signature design, logging platform setup, and idempotency strategies to help backend developers create consistent and reliable interfaces.
This article explains GraphQL's origin, its five core design principles, how a GraphQL server is structured, and compares its single‑endpoint, type‑safe approach to traditional RESTful APIs, highlighting performance and developer‑experience advantages despite higher initial setup costs.
The article examines why enums, while type‑safe and convenient for input parameters, are often criticized in API return values due to their lack of extensibility and the risk of deserialization errors when newer enum constants appear after version upgrades.
The article explains why using enums as API return values is often criticized, highlighting their lack of extensibility, potential serialization errors when newer enum values appear, and contrasting this with the safety they provide as input parameters, illustrated with Java examples and community opinions.
This article examines common pitfalls of null values in Java backend code, explains why returning null collections or objects can cause NullPointerExceptions, and presents robust solutions such as returning empty collections, using Optional, applying JSR‑303 validation, JSR‑305 annotations, and the Null Object pattern to improve API safety and readability.
This article explains the need for front‑back separation, outlines the challenges of SPA architecture, provides a step‑by‑step implementation guide, and details a version‑1.0 API specification—including request/response formats, special data handling, and future front‑end trends—helping teams reduce integration effort and improve code maintainability.
Mobile developers should learn backend development to improve communication, resolve API inconsistencies, build data aggregation layers, and create their own infrastructure, and can start by mastering Spring Boot, SSM architecture, Dubbo, MySQL/MyBatis, and optional tools like Redis and security frameworks.
This article presents ten GraphQL principles—grouped into integrity, agility, and operations—that guide the design, evolution, and secure large‑scale deployment of a unified data‑graph layer, emphasizing a single schema, collaborative implementation, schema registries, performance monitoring, and structured logging.
This article examines why robust API specifications are crucial for cloud services, outlines seven major challenges—from choosing design patterns and resource modeling to error handling, versioning, and ecosystem integration—and offers practical guidance for building consistent, reliable OpenAPI interfaces at scale.
This article explains how microservices, unlike monolithic applications, rely on inter‑process communication mechanisms, describes various interaction styles, API definition and evolution, handling partial failures, and compares synchronous (REST, Thrift) and asynchronous (messaging) IPC technologies.
This article distills the key recommendations from the 2017 PyCon talk “How to make a good library API”, offering a concise checklist that covers simplicity, consistency, flexibility, and security to help Python developers create intuitive, maintainable, and robust library interfaces.
This article examines why GraphQL naturally emerges for complex front‑end data needs, details its language design, architecture, resolver middleware, mocking strategies, and various deployment patterns such as API‑gateway and BFF, offering practical guidance for building scalable GraphQL services.
This article explains why NullPointerExceptions occur in Java, introduces the Optional class from Java 8 as a type‑safe alternative to null, and provides practical tips, code examples, and real‑world cases for using Optional to simplify error handling and improve API design.
This article examines the pitfalls of using static pageSize and pageIndex parameters for pagination on rapidly changing data sets, illustrates how data shifts can cause duplicate or missing records, and proposes client‑side de‑duplication, server‑side last‑ID pagination, and business‑level tolerance strategies.
This article explores the challenges of API design, outlines fundamental principles such as clear mental models, simplicity, multiple implementations, and idempotency, and provides concrete best‑practice recommendations illustrated with the classic POSIX File API example.
This article explains what GraphQL is, how it solves common REST API problems, details its request structure, schema, type system, fragments, aliases, interfaces, unions, and resolvers, and provides a step‑by‑step tutorial for creating a GraphQL server using ThinkJS, MongoDB, and Apollo Server, while also outlining its advantages and drawbacks.
This article, based on a 2017 PyCon talk, provides a comprehensive checklist of best‑practice guidelines—covering simplicity, consistency, flexibility, and security—to help developers create intuitive, maintainable, and Pythonic library APIs.
This article explores core API design principles—clear mental models, simplicity, multiple implementations—and offers concrete best‑practice guidance, from documentation and resource modeling to idempotency, compatibility, batch updates, and error handling, illustrated with the classic POSIX File API.
This article explores why API design is crucial for large‑scale software systems, outlines fundamental design principles, presents detailed best‑practice recommendations, and discusses compatibility, idempotency, error handling, and versioning with concrete examples such as the POSIX File API.
The article provides a comprehensive analysis of React Hooks, covering their injection model, persistent call ordering, debugging and testing strategies, API design considerations such as useReducer, Context Provider, useEffect, missing APIs, type handling, compilation optimizations, safety concerns, and the overall motivation behind moving from class components to hooks.
This article provides a comprehensive checklist for designing Java APIs, covering package organization, naming conventions, type, method, exception, constructor, and documentation best practices, using clear directives such as “must”, “should”, “consider”, and “avoid” to help developers create clean, maintainable, and robust APIs.
This article distills key recommendations from a 2017 PyCon talk into a practical checklist for building Python library APIs, covering simplicity, consistency, flexibility, and security to help developers create intuitive, reliable, and well‑structured interfaces.
This article shares practical strategies for avoiding system failures by doubting third‑party services, protecting against misuse by consumers, and strengthening internal design through solid API practices, resource limits, and disciplined coding principles.
The article describes how to build a Go‑based backend for a WeChat lottery mini‑program using the Echo framework, Tencent Cloud load balancer, Nginx, Redis and MySQL, detailing the system architecture, API design, database and Redis integration, WeChat login flow, activity state machine, and lessons learned.
This article explains how to design highly available, flexible, and durable APIs by identifying consumers, defining resources and operations, choosing the right API style, and following best practices such as proper HTTP methods, clear error messages, and hypermedia (HATEOAS) support.
The article outlines frequent pitfalls in Java API design—such as inconsistent return formats, neglecting error cases, irrelevant or overly complex parameters, and missing essential response data—and advocates using a standardized ResultBean to improve readability, AOP integration, and automated testing.
This article compares REST, gRPC, GraphQL, and Webhooks, explaining the scenarios each is best suited for and helping developers decide which API design approach matches their project's performance, flexibility, and integration requirements.
This article explains the RESTful architectural style, detailing its core constraints such as resource identification, representation, stateless state transfer, and the uniform interface, and compares REST with RPC while outlining Java frameworks and multi‑layer designs for building scalable backend web services.
GraphQL, created by Facebook in 2012 and open‑sourced in 2015, offers a flexible, efficient alternative to REST by allowing clients to request exactly the data they need, reducing redundancy, cutting request counts, and simplifying API evolution, with practical Node server and Apollo client implementations illustrated.
This guide explains the nine HTTP methods, highlights the five most common ones for RESTful APIs, outlines essential API design principles, and details proper usage of HTTP status codes and error responses to build robust, maintainable backend services.
The article presents practical strategies for avoiding service failures by treating third‑party dependencies as unreliable, designing robust APIs for consumers, and applying solid engineering principles such as degradation plans, timeout settings, traffic control, and resource‑limiting techniques.
This article explains microservices architecture, contrasting it with monolithic systems, outlines its core characteristics, communication patterns, advantages, disadvantages, design considerations, API importance, governance practices, fault‑tolerance strategies, container integration, and real‑world examples such as Netflix and Twitter.
This article, based on a 2017 PyCon talk, presents a comprehensive checklist for building Python library APIs, covering simplicity, consistency, flexibility, and security with concrete examples and actionable guidelines to help developers create intuitive and reliable interfaces.
This article outlines a practical seven‑step methodology for designing, documenting, and publishing Web APIs—covering everything from listing semantic descriptors and drawing state diagrams to harmonizing names, choosing media types, creating semantic profiles, writing code, and finally releasing a stable, consumable service.
This article presents a comprehensive guide to API design for mobile applications, covering documentation standards, common request and response parameters, naming conventions, thin‑client principles, extensibility, security, compatibility, performance and user‑experience optimizations, with practical examples and code snippets.
This article explains the background of RESTful APIs, outlines recommended URL and parameter formats, details HTTP methods, response structures, filtering, pagination, status codes, hypermedia links, and extension considerations to help developers design robust, standardized backend services.
This article explains the origins, core concepts, design principles, common misconceptions, and maturity levels of RESTful APIs, illustrating how resources, representations, HTTP verbs, and hypermedia (HATEOAS) together enable scalable, decoupled web services for modern client platforms.
This article explains how using a POST‑then‑PUT workflow can prevent duplicate resource creation in HTTP APIs, illustrated with PayPal’s payment endpoint, and why this pattern offers a more reliable, idempotent solution for backend services.
This article explains how Suning built a standardized, high‑availability API gateway, detailing naming conventions, documentation practices, protocol choices, error‑code design, dynamic configuration, SDK automation, system refactoring, monitoring, intelligent alerting, and the specific preparations made for the O2O shopping festival.
This article explains why GraphQL addresses key limitations of REST APIs—reducing round‑trips, improving client‑server decoupling, and enhancing developer experience—while also discussing its flexibility costs, security concerns, caching strategies, and practical code examples comparing both approaches using a Star Wars data scenario.
This article presents a comprehensive, academically‑styled guide for designing a unified RESTful API, covering core concepts such as REST constraints, HATEOAS, security, idempotency, URL naming conventions, request/response structures, version control, and recommended implementation tools.
This article presents ten concise best‑practice guidelines for designing clean, efficient REST APIs, covering proper use of HTTP methods, status codes, headers, framework selection, black‑box testing, and five additional crucial recommendations to help developers create elegant and maintainable web services.
This article reflects on a failed outsourcing project, detailing how unclear requirements, rushed technology choices, Vue pitfalls, mock server setup, error handling, and API design mistakes led to difficulties and offering practical lessons for future frontend development work.
This article explains the concept, benefits, and implementation details of a unified error‑code management platform, covering code allocation, handling strategies in microservice architectures, API security considerations, and performance optimizations to reduce development friction and improve system reliability.
The article reviews common payment channels such as Alipay, WeChat Pay, and point‑deduction models, analyzes their interface designs, security checks, and optional steps, and summarizes the mandatory API and security components required for robust payment system integration.
The article outlines key challenges in distributed API design—including date formatting, decimal precision, response structures, idempotency, security, and naming consistency—and provides practical recommendations to improve usability, scalability, and maintainability across backend services.
This comprehensive guide explores the fundamentals of API design for front‑end development, covering naming conventions, lexical correctness, parameter ordering, return values, versioning, and extensibility, and provides practical code examples to help developers create intuitive, maintainable, and future‑proof interfaces.
This article traces the evolution of APIs from early mechanical automata and historic milestones like Deep Blue to today’s REST‑based Web APIs, highlights current challenges such as documentation drift and versioning, and proposes autonomous, self‑describing APIs powered by vocabularies and discovery services.
This article presents comprehensive API design standards for mobile apps, covering request/response conventions, naming rules, data type handling, security measures, compatibility, performance and user‑experience optimizations, and offers practical examples to help front‑end and back‑end engineers create robust, maintainable interfaces.
Effective API design requires shifting from a developer‑centric mindset to the user’s perspective, emphasizing clear documentation, stability, versioning, flexibility, security, and ease of use, while avoiding unnecessary complexity and ensuring consistent, well‑structured interfaces for diverse clients across web, mobile, and IoT platforms.
The article explores the rise of experience APIs and Backends for Frontends, discussing how microservice architectures, API facades, custom payloads, media types, Prefer headers, and GraphQL can be used to tailor APIs for diverse client platforms while weighing the trade‑offs for small versus large teams.
GitHub introduced a GraphQL‑based public API to overcome REST’s scalability and flexibility limits, allowing clients to specify exact data needs, reduce network overhead, and combine multiple queries into a single request, while offering features like batching, subscriptions, and data latency control.
This guide demystifies RESTful API design by explaining the role of each HTTP method, resource types, URL conventions, and best‑practice principles, using clear diagrams so beginners can grasp how to build scalable, maintainable backend services.
This article explains the fundamentals of RESTful architecture—including resources, uniform interfaces, URIs, statelessness—and compares it with ROA, SOA, and RPC, while also covering authentication methods such as Basic, Token, and OAuth, offering practical guidance for building robust microservice APIs.
This article analyzes how APIs create commercial opportunities, explains the criteria of practicality and usability, examines case studies such as Amazon and Twilio, and provides a step‑by‑step guide for designing APIs that deliver accurate, accessible data and drive business growth.
This article highlights the two most critical performance mistakes identified by Martin Thompson—excessive logging and poorly designed APIs—illustrating how logging threads can linearly increase latency and proposing better API signatures such as returning iterators or using caller‑provided collections to boost efficiency.
The article explores the multiple demands on internet systems, explains why business service granularity is the biggest obstacle to microservice adoption, and shares practical insights on designing a cloud‑native platform with Docker, Kubernetes, unified monitoring, API governance, and multi‑tenant resource isolation.
This article explains how GraphQL’s schema and type system model complex business data, and how its query language lets front‑end developers freely compose and customize data requests, covering core components, scalar and advanced types, queries, fragments, directives, and practical code examples.
This article explains how to design a well‑structured RESTful API by covering protocol choice, domain naming, versioning, endpoint conventions, HTTP verbs, filtering, status codes, error handling, response formats, hypermedia links, authentication, and data format recommendations.
This article explains why developer experience matters for API products, defines DX, outlines empathy‑driven principles, and provides concrete guidelines—clear documentation, easy onboarding, robust debugging tools, supportive channels, and community‑focused practices—to help API designers create more appealing and competitive services.
An experienced backend engineer shares practical strategies to prevent service failures, covering third‑party distrust, user‑side safeguards, robust API design, traffic limiting, resource management, and architectural best practices such as single‑responsibility and avoiding single points of failure.
This article presents practical guidelines for designing, versioning, securing, and documenting RESTful APIs, covering resource modeling, URL conventions, filtering, sorting, pagination, authentication, rate limiting, error handling, and response formats to help developers build flexible and user‑friendly public APIs.
The article shares Meiya's journey from a small startup to a full‑featured beauty video platform, detailing common early‑stage challenges, communication and protocol strategies, RESTful API design, development workflow, toolchain choices like Laravel, DB migrations, iOS libraries, ELK logging, and DevOps automation with SaltStack.
The article analyzes the practical differences and overlaps between RESTful APIs and Service‑Oriented Architecture, offering guidance on when to build services versus APIs, outlining each approach’s focus, best practices, and a step‑by‑step method for creating RESTful APIs within a unified strategy.
This article outlines a repeatable, seven‑step process for designing robust Web APIs that leverages both HTTP and broader Web protocols, covering everything from listing semantic descriptors to publishing the API, and emphasizes clear separation of design and implementation details for future extensibility.
This article presents a comprehensive, seven‑step methodology for designing, implementing, and maintaining Web APIs—covering business use‑case definition, semantic description, state‑diagram modeling, naming harmonization, media‑type selection, semantic archive creation, coding, and publishing—while offering interviews and further reading recommendations.
