Custom exception handlers in FastAPI - Performance & Optimization

Performance: Custom exception handlers

MEDIUM IMPACT

This affects server response time and user experience by controlling how errors are processed and returned.

Handling errors in FastAPI to provide user-friendly messages

FastAPI

from fastapi import FastAPI
from fastapi.responses import JSONResponse
app = FastAPI()

@app.exception_handler(Exception)
async def generic_exception_handler(request, exc):
    # Minimal processing, quick response
    return JSONResponse(status_code=500, content={"detail": "Internal Server Error"})

Avoids blocking calls and heavy processing, returning error quickly to client.

📈 Performance GainResponse sent immediately, reducing INP and improving user experience

Handling errors in FastAPI to provide user-friendly messages

FastAPI

from fastapi import FastAPI
from fastapi.responses import JSONResponse
app = FastAPI()

@app.exception_handler(Exception)
async def generic_exception_handler(request, exc):
    # Heavy logging and complex processing here
    import time
    import asyncio
    await asyncio.sleep(2)  # Simulate slow processing asynchronously
    return JSONResponse(status_code=500, content={"detail": "Internal Server Error"})

Blocking or slow processing in exception handlers delays server response, increasing input latency.

📉 Performance CostBlocks response for 2 seconds, increasing INP and user wait time

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
Heavy blocking exception handler	N/A	N/A	N/A	[X] Bad
Lightweight async exception handler	N/A	N/A	N/A	[OK] Good

Rendering Pipeline

When an exception occurs, FastAPI routes it to the custom handler which processes and returns a response. Slow handlers delay the server's response, impacting interaction responsiveness.

→Server Processing

→Response Generation

⚠️ BottleneckServer Processing due to heavy or blocking operations in handler

Core Web Vital Affected

INP

This affects server response time and user experience by controlling how errors are processed and returned.

Optimization Tips

1Avoid blocking or heavy processing in custom exception handlers.

2Use asynchronous code to keep handlers fast and non-blocking.

3Return error responses quickly to improve input responsiveness (INP).

Performance Quiz - 3 Questions

What is the main performance risk of a slow custom exception handler in FastAPI?

A It causes layout shifts on the page.

B It increases the number of DOM nodes on the client.

C It delays the server response, increasing input latency.

D It increases CSS selector complexity.

DevTools: Network

How to check: Open DevTools, go to Network tab, trigger an error, and observe the response time for error responses.

What to look for: Look for long response times on error requests indicating slow exception handling.

Practice

1. What is the main purpose of a custom exception handler in FastAPI?

easy

A. To catch specific errors and return user-friendly responses

B. To speed up the server response time

C. To automatically fix bugs in the code

D. To log all incoming requests

Solution

1. Step 1: Understand what exception handlers do

   They catch errors that happen during request processing.

2. Step 2: Identify the benefit of custom handlers

   They allow sending clear, friendly messages instead of default error pages.

3. Final Answer:

   To catch specific errors and return user-friendly responses -> Option A

4. Quick Check:

   Custom handlers improve user experience = B [OK]

Hint: Custom handlers catch errors and explain them clearly [OK]

Common Mistakes:

• Thinking they fix bugs automatically
• Confusing with logging or performance tools
• Assuming they speed up requests

2. Which of the following is the correct way to register a custom exception handler in FastAPI?

easy

A. app.add_exception_handler(MyException, handler_function)

B. app.register_handler(MyException, handler_function)

C. app.use_exception_handler(MyException, handler_function)

D. app.exception_handler(MyException, handler_function)

Solution

1. Step 1: Recall FastAPI method for adding handlers

   FastAPI uses add_exception_handler to register handlers.

2. Step 2: Check method names in options

   Only app.add_exception_handler(MyException, handler_function) uses the correct method name and parameters.

3. Final Answer:

   app.add_exception_handler(MyException, handler_function) -> Option A

4. Quick Check:

   Correct method is add_exception_handler = D [OK]

Hint: Use add_exception_handler to register custom handlers [OK]

Common Mistakes:

• Using wrong method names like register_handler
• Confusing decorator syntax with registration
• Passing wrong parameters order

3. Given this code snippet, what will be the HTTP status code returned when MyException is raised?

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse

app = FastAPI()

class MyException(Exception):
    pass

@app.exception_handler(MyException)
async def my_exception_handler(request: Request, exc: MyException):
    return JSONResponse(status_code=418, content={"message": "Custom error occurred"})

@app.get("/test")
async def test():
    raise MyException()

medium

A. 404

B. 418

C. 200

D. 500

Solution

1. Step 1: Identify the status code in the handler

   The handler returns a JSONResponse with status_code=418.

2. Step 2: Understand what happens when exception is raised

   Raising MyException triggers the handler, which sends the 418 status.

3. Final Answer:

   418 -> Option B

4. Quick Check:

   Handler sets status 418 = A [OK]

Hint: Check the status_code in JSONResponse inside handler [OK]

Common Mistakes:

• Assuming default 500 error code
• Confusing 404 with missing route
• Ignoring custom status_code in handler

4. What is wrong with this FastAPI custom exception handler code?

from fastapi import FastAPI

app = FastAPI()

class CustomError(Exception):
    pass

@app.exception_handler(CustomError)
def handler(exc: CustomError):
    return {"error": "Something went wrong"}

medium

A. Return value must be a string, not a dict

B. Exception class must inherit from HTTPException

C. Handler function must be async and accept Request parameter

D. Decorator should be @app.add_exception_handler, not @app.exception_handler

Solution

1. Step 1: Check handler function signature

   FastAPI expects async handler with parameters (Request, Exception).

2. Step 2: Identify missing Request and async

   The handler lacks the Request parameter and is not async.

3. Final Answer:

   Handler function must be async and accept Request parameter -> Option C

4. Quick Check:

   Handler signature requires async and Request = C [OK]

Hint: Handler must be async and take Request as first argument [OK]

Common Mistakes:

• Making handler synchronous
• Omitting Request parameter
• Thinking exception must inherit HTTPException

5. You want to create a custom exception handler in FastAPI that returns a JSON response with a dynamic message and a 400 status code whenever ValueError is raised. Which code snippet correctly implements this?

hard

A. from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse

app = FastAPI()

@app.exception_handler(ValueError)
async def value_error_handler(request: Request, exc: ValueError):
return JSONResponse(content={"error": str(exc)}, status=400)

B. from fastapi import FastAPI

app = FastAPI()

@app.exception_handler(ValueError)
def value_error_handler(exc: ValueError):
return {"error": str(exc), "status": 400}

C. from fastapi import FastAPI, Request

app = FastAPI()

@app.add_exception_handler(ValueError)
async def value_error_handler(request: Request, exc: ValueError):
return {"error": str(exc), "status_code": 400}

D. from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse

app = FastAPI()

@app.exception_handler(ValueError)
async def value_error_handler(request: Request, exc: ValueError):
return JSONResponse(status_code=400, content={"error": str(exc)})

Solution

1. Step 1: Check correct decorator and function signature

   Use @app.exception_handler with async function taking (Request, Exception).

2. Step 2: Verify JSONResponse usage and status code

   Return JSONResponse with status_code=400 and content with error message.

3. Step 3: Identify correct option

   from fastapi import FastAPI, Request from fastapi.responses import JSONResponse app = FastAPI() @app.exception_handler(ValueError) async def value_error_handler(request: Request, exc: ValueError): return JSONResponse(status_code=400, content={"error": str(exc)}) matches all requirements exactly.

4. Final Answer:

   A -> Option D

5. Quick Check:

   Correct async handler with JSONResponse and status_code=400 = A [OK]

Hint: Use async handler with JSONResponse and status_code param [OK]

Common Mistakes:

• Using synchronous handler
• Missing Request parameter
• Wrong decorator or status code parameter name
• Returning dict instead of JSONResponse