Shared dependencies in FastAPI - Performance & Optimization

Performance: Shared dependencies

MEDIUM IMPACT

This affects server response time and resource usage by reusing common logic or resources across multiple routes.

Reusing common logic or resources in multiple API endpoints

FastAPI

from fastapi import Depends

from fastapi import FastAPI
app = FastAPI()

shared_db = None

def get_shared_db():
    global shared_db
    if shared_db is None:
        shared_db = create_new_db_connection()
    try:
        yield shared_db
    finally:
        pass  # Do not close shared connection here

@app.get('/items')
async def read_items(db=Depends(get_shared_db)):
    return db.query_items()

@app.get('/users')
async def read_users(db=Depends(get_shared_db)):
    return db.query_users()

Reuses a single shared database connection across requests, reducing connection overhead and speeding up responses.

📈 Performance GainReduces connection setup time, lowers resource consumption, and improves throughput.

Reusing common logic or resources in multiple API endpoints

FastAPI

from fastapi import Depends

from fastapi import FastAPI
app = FastAPI()

def get_db():
    db = create_new_db_connection()
    try:
        yield db
    finally:
        db.close()

@app.get('/items')
async def read_items(db=Depends(get_db)):
    return db.query_items()

@app.get('/users')
async def read_users(db=Depends(get_db)):
    return db.query_users()

Creates a new database connection for each request and each endpoint separately, causing overhead and slower responses.

📉 Performance CostBlocks request handling for connection setup per endpoint, increasing latency and resource use.

Performance Comparison

Pattern	Resource Usage	Request Latency	Throughput	Verdict
Separate dependency per endpoint	High (multiple connections)	Higher (connection setup per request)	Lower	[X] Bad
Shared dependency instance	Low (single shared connection)	Lower (reuse connection)	Higher	[OK] Good

Rendering Pipeline

Shared dependencies reduce server-side processing time before sending the response, improving backend efficiency but do not directly affect browser rendering.

→Server Processing

→Response Time

⚠️ BottleneckRepeated resource initialization per request

Optimization Tips

1Declare shared dependencies to reuse expensive resources across requests.

2Avoid creating new resource instances in every endpoint handler.

3Use FastAPI's dependency injection to manage shared resources efficiently.

Performance Quiz - 3 Questions

What is the main performance benefit of using shared dependencies in FastAPI?

A Increases the number of database connections

B Blocks the event loop for longer

C Reduces redundant resource initialization across requests

D Adds extra middleware layers

DevTools: Network

How to check: Open DevTools, go to Network tab, observe response times for API calls under different dependency setups.

What to look for: Look for reduced response latency and faster server response times when using shared dependencies.

Practice

1. What is the main purpose of using Depends() in FastAPI for shared dependencies?

easy

A. To reuse code across multiple routes by declaring common dependencies

B. To create a new route in the application

C. To handle database connections manually

D. To define the response model for an endpoint

Solution

1. Step 1: Understand the role of Depends()

   Depends() is used in FastAPI to declare dependencies that can be shared across multiple routes.

2. Step 2: Identify the main benefit

   Using shared dependencies helps reuse code and keep the app clean and maintainable.

3. Final Answer:

   To reuse code across multiple routes by declaring common dependencies -> Option A

4. Quick Check:

   Shared dependencies = reuse code [OK]

Hint: Depends() means shared code for many routes [OK]

Common Mistakes:

• Thinking Depends() creates routes
• Confusing Depends() with response models
• Assuming Depends() manages database connections directly

2. Which of the following is the correct way to declare a shared dependency in a FastAPI route?

easy

A. def get_db(): return Session(); @app.get('/items') def read_items(db=Depends(get_db)): pass

B. def get_db(): return Session(); @app.get('/items') def read_items(db=get_db()): pass

C. def get_db(): return Session(); @app.get('/items') def read_items(db: Session): pass

D. def get_db(): return Session(); @app.get('/items') def read_items(db=Depends()): pass

Solution

1. Step 1: Review correct dependency syntax

   In FastAPI, dependencies are declared using Depends(function_name) inside the function parameters.

2. Step 2: Check each option

   def get_db(): return Session(); @app.get('/items') def read_items(db=Depends(get_db)): pass correctly uses db=Depends(get_db). def get_db(): return Session(); @app.get('/items') def read_items(db=get_db()): pass calls the function directly, which is incorrect. def get_db(): return Session(); @app.get('/items') def read_items(db: Session): pass lacks Depends, so no injection happens. def get_db(): return Session(); @app.get('/items') def read_items(db=Depends()): pass uses Depends without a function, which is invalid.

3. Final Answer:

   def get_db(): return Session(); @app.get('/items') def read_items(db=Depends(get_db)): pass -> Option A

4. Quick Check:

   Depends() needs function inside [OK]

Hint: Depends() must wrap the dependency function [OK]

Common Mistakes:

• Calling dependency function directly in parameter
• Forgetting to use Depends() wrapper
• Using Depends() without specifying the function

3. Given the code below, what will be the output when accessing /items/42?

from fastapi import FastAPI, Depends

app = FastAPI()

def common_dep():
    return "shared value"

@app.get('/items/{item_id}')
def read_item(item_id: int, value: str = Depends(common_dep)):
    return {"item_id": item_id, "value": value}

medium

A. Error: Missing required parameter 'value'

B. {"item_id": 42, "value": 42}

C. {"item_id": 42, "value": null}

D. {"item_id": 42, "value": "shared value"}

Solution

1. Step 1: Understand dependency injection

   The function common_dep returns the string "shared value". FastAPI injects this into the value parameter via Depends(common_dep).

2. Step 2: Check the returned JSON

   The route returns a dictionary with item_id from the path and value from the dependency. So the output will be {"item_id": 42, "value": "shared value"}.

3. Final Answer:

   {"item_id": 42, "value": "shared value"} -> Option D

4. Quick Check:

   Dependency injects "shared value" [OK]

Hint: Depends injects return value as parameter [OK]

Common Mistakes:

• Assuming dependency returns item_id
• Expecting error due to missing parameter
• Thinking value will be null without explicit call

4. Identify the error in the following FastAPI code using shared dependencies:

from fastapi import FastAPI, Depends

app = FastAPI()

def get_token():
    return "token123"

@app.get('/secure')
def secure_route(token: str = Depends()):
    return {"token": token}

medium

A. The function secure_route should not have parameters

B. The dependency function get_token() should return an int

C. Depends() is missing the dependency function inside

D. The route decorator is missing parentheses

Solution

1. Step 1: Check Depends usage

   The parameter token uses Depends() without specifying the dependency function. This is incorrect syntax.

2. Step 2: Correct usage

   Depends must wrap the function providing the dependency, so it should be Depends(get_token).

3. Final Answer:

   Depends() is missing the dependency function inside -> Option C

4. Quick Check:

   Depends() needs function argument [OK]

Hint: Depends() always needs a function inside [OK]

Common Mistakes:

• Using Depends() without argument
• Expecting Depends() to work without function
• Confusing Depends() with decorator syntax

5. You want to share a database session dependency across multiple routes but also ensure it closes after each request. Which approach correctly uses shared dependencies with cleanup in FastAPI?

hard

A. Create the session globally once and reuse it without closing

B. Use a dependency function with yield that creates the session, yields it, then closes it after

C. Pass the session as a normal parameter without Depends()

D. Use Depends() but close the session manually inside each route

Solution

1. Step 1: Understand dependency cleanup

   FastAPI supports dependencies with cleanup by using yield inside the dependency function. This allows setup before yield and cleanup after.

2. Step 2: Apply to database session

   The correct pattern is to create the session, yield it for use in routes, then close it after the request finishes.

3. Final Answer:

   Use a dependency function with yield that creates the session, yields it, then closes it after -> Option B

4. Quick Check:

   Yield in dependency = setup and cleanup [OK]

Hint: Use yield in dependency for setup and cleanup [OK]

Common Mistakes:

• Reusing global session without closing
• Closing session inside route instead of dependency
• Not using Depends() for session injection