Should a single API call handle everything to make life of frontend easy, or there be as many apis as needed

by

Summary

The question of whether a single API call should handle everything to make life easier for frontend developers or if there should be as many APIs as needed is a common dilemma. Tight coupling and code duplication are two primary concerns when designing APIs. As a senior production engineer, it’s essential to strike a balance between simplicity and maintainability.

Root Cause

The root cause of this issue is the desire to simplify the frontend development process by reducing the number of API calls. However, this approach can lead to:

  • Tight coupling between the frontend and backend
  • Code duplication when role-based rules are implemented in the frontend
  • Inflexibility when changes are required

Why This Happens in Real Systems

This issue arises in real systems due to:

  • Lack of clear architecture: Unclear boundaries between frontend and backend responsibilities
  • Insufficient communication: Poor communication between frontend and backend teams
  • Tight deadlines: Rushed development leading to shortcuts and compromises

Real-World Impact

The impact of this approach can be significant:

  • Maintainability issues: Difficult to update or modify APIs without affecting the frontend
  • Scalability problems: Increased latency and decreased performance due to complex API calls
  • Security risks: Exposed sensitive data or functionality due to overly permissive APIs

Example or Code

# Example of a tightly coupled API
from django.http import JsonResponse
from django.views.decorators.http import require_http_methods

@require_http_methods(["GET"])
def get_order_details(request, order_id):
    # Fetch order data
    order_data = Order.objects.get(id=order_id)

    # Determine role-based visibility
    if request.user.is_staff:
        visible_fields = ["order_date", "quantity"]
    elif request.user.is_supervisor:
        visible_fields = ["order_date", "quantity", "unit", "sale_cost"]

    # Return filtered data
    return JsonResponse({field: getattr(order_data, field) for field in visible_fields})

How Senior Engineers Fix It

Senior engineers address this issue by:

  • Decoupling frontend and backend responsibilities
  • Implementing clear architecture and APIs
  • Establishing open communication between teams
  • Prioritizing maintainability and scalability
  • Using techniques like API gateways and microservices to manage complexity

Why Juniors Miss It

Junior engineers may miss this issue due to:

  • Lack of experience: Limited exposure to large-scale systems and complex APIs
  • Insufficient training: Inadequate education on software architecture and design principles
  • Focus on short-term goals: Prioritizing quick fixes over long-term maintainability and scalability

Leave a Comment