Shared dependencies across routers in FastAPI - Performance & Optimization

Performance: Shared dependencies across routers

MEDIUM IMPACT

This affects the server response time and resource usage by controlling how often dependencies are created and reused across different routes.

Using the same dependency in multiple routers

FastAPI

from fastapi import FastAPI, Depends, APIRouter

app = FastAPI()

async def common_dep():
    # expensive setup
    return 'resource'

app_dependency = Depends(common_dep)

router1 = APIRouter(dependencies=[app_dependency])
@router1.get('/items')
async def items(dep=Depends(common_dep)):
    return {'dep': dep}

router2 = APIRouter(dependencies=[app_dependency])
@router2.get('/users')
async def users(dep=Depends(common_dep)):
    return {'dep': dep}

app.include_router(router1)
app.include_router(router2)

The dependency is declared once at the router level and shared, so it runs only once per request for all routes in that router.

📈 Performance GainReduces redundant calls, lowering CPU usage and improving response time.

Using the same dependency in multiple routers

FastAPI

from fastapi import FastAPI, Depends, APIRouter

app = FastAPI()

async def common_dep():
    # expensive setup
    return 'resource'

router1 = APIRouter()
@router1.get('/items')
async def items(dep=Depends(common_dep)):
    return {'dep': dep}

router2 = APIRouter()
@router2.get('/users')
async def users(dep=Depends(common_dep)):
    return {'dep': dep}

app.include_router(router1)
app.include_router(router2)

The dependency common_dep is called separately for each router and each request, causing repeated expensive setup.

📉 Performance CostTriggers redundant dependency calls per request, increasing response time and CPU usage.

Performance Comparison

Pattern	Dependency Calls	CPU Usage	Response Time	Verdict
Separate dependency per route	Multiple calls per request	High	Slower	[X] Bad
Shared dependency at router level	Single call per request per router	Lower	Faster	[OK] Good

Rendering Pipeline

In FastAPI, dependencies are resolved before route handlers execute. Shared dependencies reduce repeated setup work, improving server processing before response generation.

→Dependency Resolution

→Request Handling

⚠️ BottleneckRepeated dependency calls increase CPU and delay response generation.

Optimization Tips

1Declare shared dependencies at router or app level to avoid repeated calls.

2Avoid declaring expensive dependencies inside each route function.

3Use FastAPI's dependencies parameter on routers to optimize resource usage.

Performance Quiz - 3 Questions

What is the main performance benefit of sharing dependencies across routers in FastAPI?

A Increases the number of dependency calls for better caching

B Makes each route load dependencies independently

C Reduces redundant dependency calls per request

D Removes the need for dependencies entirely

DevTools: Network and Performance panels

How to check: Use the Network panel to measure response times for routes using shared vs separate dependencies. Use Performance panel to profile CPU usage during requests.

What to look for: Look for lower response times and reduced CPU spikes when shared dependencies are used.