If you are not using WunderGraph (opens in a new tab) on WunderGraph Cloud (opens in a new tab) to create your BFF and are instead using a custom solution, there are a few things to consider when implementing the BFF pattern.

Distributed Tracing

  1. Complexity: Implementing distributed tracing across microservices can be complex, requiring the integration of various components such as trace collectors, visualization tools, and instrumentation libraries. It's essential to choose the right tools and have a clear understanding of the tracing process to ensure a successful implementation.

  2. Overhead: Instrumenting your services for distributed tracing may introduce some performance overhead, depending on the tracing method and granularity. Carefully evaluate the impact of tracing on your system's performance, and consider sampling or other strategies to reduce overhead.

  3. Standardization: Adopting standardized tracing protocols, such as OpenTelemetry or OpenTracing, can ease integration with various tools and platforms, enabling more efficient trace collection, analysis, and visualization.

  4. Security and Data Privacy: Ensure that sensitive data is not inadvertently exposed or logged in trace data, and take appropriate measures to protect trace data in transit and at rest.

Server-side Page Fragment Composition

  1. Performance: Server-side page fragment composition can impact server-side rendering performance, especially when composing pages with many fragments or when fragments are fetched from multiple remote services. Consider caching strategies and performance optimizations to minimize the impact on server-side rendering.

  2. Error Handling: Ensure proper error handling and fallback strategies for cases where remote services or fragments are unavailable or slow to respond, to maintain a positive user experience.

  3. Maintainability: Implementing server-side page fragment composition can increase the complexity of your server-side code. Develop a clear structure and conventions for organizing and managing fragment composition to maintain code quality and readability.

  4. Reusability: Design fragments with reusability in mind, considering different contexts and use cases to maximize the benefits of server-side page fragment composition.


  1. Scalability: Ensure that your API Hub can handle the increasing number of services and API requests as your system grows, considering factors such as caching, rate limiting, and load balancing.

  2. Security: Implement proper authentication and authorization mechanisms to protect your APIs from unauthorized access and potential security threats.

  3. Monitoring and Observability: Monitor the performance and health of your API Hub, and collect metrics and logs for analysis and debugging purposes.

  4. Versioning and Deprecation: Establish a clear versioning strategy for your APIs and communicate changes to consumers to avoid breaking changes and ensure a smooth transition between API versions.

BFF Sidecar

  1. Deployment and Configuration: Carefully consider the deployment and configuration options for the BFF sidecar, including containerization and service mesh integration, to ensure seamless deployment alongside your existing services.

  2. Resource Usage: Evaluate the resource usage of the BFF sidecar to ensure that it does not negatively impact the performance of your services or consume excessive resources.

  3. Maintainability: Implement clear separation of concerns between the BFF sidecar and your services, ensuring that the sidecar focuses on API aggregation, transformation, and protocol translation while keeping the service logic intact.

  4. Monitoring and Observability: Ensure that the BFF sidecar provides sufficient visibility into its operation, exposing metrics and logs for monitoring, troubleshooting, and performance optimization.

Type-Safe API Composition Testing

  1. Test Coverage: Develop a comprehensive set of test cases to cover various API composition scenarios, including normal operation, error handling, and edge cases.

  2. Mocking and Stubbing: Use mocking and stubbing techniques to isolate individual services and components during testing, allowing you to validate the API composition logic without relying on live dependencies.

  3. Continuous Integration and Deployment: Integrate type-safe API composition testing into your CI/CD pipeline to catch potential issues early and prevent faulty compositions from being deployed to production.

  4. Test Maintainability: Keep your test suite well-organized,