Backend Layered Architecture and API Design Questions

Covers server side layering patterns and API design best practices. Topics include controller or handler layers, service and business logic layers, data access layers, repository patterns, dependency injection, API design (RESTful, gRPC), versioning, authentication and authorization patterns, pagination and rate limiting, and when to apply specific patterns to improve maintainability and testability.

EasyTechnical

69 practiced

Explain dependency injection (DI). Describe the difference between constructor injection, setter injection, and service locators. For a Solutions Architect designing a layered backend, what are the advantages and potential pitfalls of using DI frameworks in service and repository layers?

EasyTechnical

40 practiced

Design a simple pagination API for listing resources that supports both offset-based and cursor-based pagination. Define query parameters, response fields, and discuss when to choose cursor-based versus offset-based paging for performance and user experience.

MediumTechnical

49 practiced

Implement a distributed per-user rate limiter in Python using Redis to enforce token bucket semantics across multiple service instances. Provide code for acquire(user_id) that returns True if the request is allowed and False otherwise. Explain your choice of Redis keys, TTLs, and how you ensure atomicity across concurrent nodes (use Lua scripts or transactions).

Sample Answer

**Approach**Use Redis token bucket with an atomic Lua script to check and update tokens per user across instances.

**Design choices**- Key: "rb:tokens:{user_id}" storing two values: last_ts and tokens (as a Redis hash or single JSON string). TTL set to life window to allow GC.- Atomicity: Lua script performs refill calculation and token decrease atomically.

**Code (Python + Redis)**

python

import time
import redis

lua = """
local key = KEYS[1]
local now = tonumber(ARGV[1])
local rate = tonumber(ARGV[2])
local capacity = tonumber(ARGV[3])
local tokens = tonumber(redis.call('HGET', key, 'tokens') or capacity)
local last = tonumber(redis.call('HGET', key, 'last') or now)
local delta = math.max(0, now - last)
local refill = math.min(capacity, tokens + delta * rate)
if refill < 1 then
  redis.call('HSET', key, 'tokens', refill)
  redis.call('HSET', key, 'last', now)
  redis.call('EXPIRE', key, 3600)
  return 0
else
  redis.call('HSET', key, 'tokens', refill - 1)
  redis.call('HSET', key, 'last', now)
  redis.call('EXPIRE', key, 3600)
  return 1
end
"""

r = redis.Redis()
script = r.register_script(lua)

def acquire(user_id, rate, capacity):
    now = int(time.time())
    key = f"rb:tokens:{user_id}"
    return bool(script(keys=[key], args=[now, rate, capacity]))

**Notes**- rate = tokens/sec, capacity = burst size.- TTL (3600s) cleans idle keys.- Lua ensures atomic read-modify-write across nodes. Use clustering-safe Redis and consider Redis Streams or RedisGears if scaling further.

MediumTechnical

60 practiced

Discuss the trade-offs between keeping controllers thin and pushing logic into services versus allowing fatter controllers that orchestrate use cases. For a Solutions Architect advising a client, when is a thin-controller approach preferable and what organizational or technical constraints might make fatter controllers acceptable?

MediumTechnical

63 practiced

Describe strategies to make a layered backend architecture highly testable. Cover unit testing, integration testing, use of dependency injection, mocking strategies for services and repositories, and how to structure tests for layered abstractions so you can catch regressions early and speed up the feedback loop.

Unlock Full Question Bank

Get access to hundreds of Backend Layered Architecture and API Design interview questions and detailed answers.

Join thousands of developers preparing for their dream job.