CRUD operations in FastAPI - Performance & Optimization

Performance: CRUD operations

MEDIUM IMPACT

CRUD operations impact server response time and client rendering speed, affecting how quickly users see and interact with data changes.

Fetching and updating data in a FastAPI app

FastAPI

from fastapi import FastAPI
import asyncio
app = FastAPI()

items = {}

@app.get('/items/{item_id}')
async def read_item(item_id: int):
    await asyncio.sleep(2)  # Non-blocking placeholder for async DB call
    return items.get(item_id, {'error': 'Not found'})

@app.post('/items/{item_id}')
async def create_item(item_id: int, item: dict):
    items[item_id] = item
    return item

Uses async non-blocking calls allowing other requests to process, improving server responsiveness.

📈 Performance GainNon-blocking I/O reduces request wait time, improving INP and overall throughput.

Fetching and updating data in a FastAPI app

FastAPI

from fastapi import FastAPI
app = FastAPI()

items = {}

@app.get('/items/{item_id}')
async def read_item(item_id: int):
    # Simulate slow DB call
    import time
    time.sleep(2)
    return items.get(item_id, {'error': 'Not found'})

@app.post('/items/{item_id}')
async def create_item(item_id: int, item: dict):
    items[item_id] = item
    return item

Blocking synchronous sleep simulates slow DB call, blocking event loop and delaying all requests.

📉 Performance CostBlocks event loop for 2 seconds per request, causing high INP and slow server response.

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
Synchronous blocking DB calls	Minimal	Multiple due to delayed updates	High due to delayed content	[X] Bad
Asynchronous non-blocking DB calls	Minimal	Single or minimal	Low due to faster content delivery	[OK] Good
Sequential synchronous updates	Minimal	Multiple reflows due to slow updates	High	[X] Bad
Parallel asynchronous updates	Minimal	Single reflow after batch update	Low	[OK] Good
Returning full large data sets	Many DOM nodes	Multiple reflows	High paint cost	[X] Bad
Paginated data responses	Few DOM nodes per page	Single reflow per page	Low paint cost	[OK] Good

Rendering Pipeline

CRUD operations affect the server response time, which influences when the browser receives data to render. Slow or blocking operations delay Style Calculation and Paint stages because the content arrives late. Efficient async operations speed up data delivery, improving the overall rendering pipeline.

→Data Fetching

→Style Calculation

→Layout

→Paint

⚠️ BottleneckData Fetching (server response time)

Core Web Vital Affected

INP

CRUD operations impact server response time and client rendering speed, affecting how quickly users see and interact with data changes.

Optimization Tips

1Avoid synchronous blocking calls in FastAPI CRUD handlers to keep the event loop free.

2Use asynchronous database operations to improve server responsiveness and reduce INP.

3Paginate large data responses to reduce payload size and improve LCP.

Performance Quiz - 3 Questions

What is the main performance problem with synchronous blocking calls in FastAPI CRUD operations?

A They reduce the number of DOM nodes.

B They block the event loop, delaying all requests.

C They increase CSS selector complexity.

D They improve server throughput.

DevTools: Performance

How to check: Record a performance profile while making CRUD requests. Look for long tasks blocking the main thread and network waterfall for large payloads.

What to look for: Long blocking tasks indicate synchronous operations; large payloads delay first contentful paint; multiple reflows show inefficient DOM updates.

Practice

1. What does CRUD stand for in FastAPI applications?

easy

A. Cache, Route, Undo, Debug

B. Create, Read, Update, Delete

C. Compile, Render, Use, Deploy

D. Connect, Run, Upload, Download

Solution

1. Step 1: Understand CRUD basics

   CRUD is a common acronym in web development representing the four basic operations on data.

2. Step 2: Match CRUD to FastAPI operations

   FastAPI supports these operations: creating, reading, updating, and deleting data.

3. Final Answer:

   Create, Read, Update, Delete -> Option B

4. Quick Check:

   CRUD = Create, Read, Update, Delete [OK]

Hint: Remember CRUD as the four main data actions [OK]

Common Mistakes:

• Confusing CRUD with unrelated terms
• Thinking CRUD includes deployment steps
• Mixing CRUD with HTTP methods only

2. Which FastAPI decorator is used to define a route for updating an existing item?

easy

A. @app.put()

B. @app.get()

C. @app.post()

D. @app.delete()

Solution

1. Step 1: Identify HTTP methods for CRUD

   Update operations typically use the HTTP PUT method.

2. Step 2: Match HTTP method to FastAPI decorator

   FastAPI uses @app.put() to define routes that update existing data.

3. Final Answer:

   @app.put() -> Option A

4. Quick Check:

   Update = @app.put() [OK]

Hint: Update uses PUT method and @app.put() decorator [OK]

Common Mistakes:

• Using @app.post() for update routes
• Confusing @app.get() with update
• Using @app.delete() instead of update

3. Given this FastAPI code snippet, what will be the response when accessing GET /items/42 if the item exists?

from fastapi import FastAPI
app = FastAPI()
items = {42: {"name": "Book", "price": 10.99}}

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    return items.get(item_id, {"error": "Item not found"})

medium

A. 404 Not Found error

B. {"error": "Item not found"}

C. {"name": "Book", "price": 10.99}

D. Empty response

Solution

1. Step 1: Understand the dictionary lookup

   The code uses items.get(item_id, {"error": "Item not found"}) which returns the item if found, else an error dict.

2. Step 2: Check if item 42 exists

   Item 42 is in the dictionary with name "Book" and price 10.99, so it will be returned.

3. Final Answer:

   {"name": "Book", "price": 10.99} -> Option C

4. Quick Check:

   Item found returns data, else error [OK]

Hint: dict.get returns value if key exists, else default [OK]

Common Mistakes:

• Assuming a 404 error is raised automatically
• Expecting an empty response if item exists
• Confusing error message with actual data

4. Identify the error in this FastAPI DELETE route code:

from fastapi import FastAPI
app = FastAPI()
items = {1: "apple", 2: "banana"}

@app.delete("/items/{item_id}")
async def delete_item(item_id: int):
    del items[item_id]
    return {"message": "Item deleted"}

medium

A. Incorrect route path syntax

B. Missing return type annotation

C. Using async def instead of def

D. Deleting item without checking if it exists

Solution

1. Step 1: Analyze deletion logic

   The code deletes the item directly without checking if the item_id exists in the dictionary.

2. Step 2: Understand potential error

   If item_id is not in items, del will raise a KeyError causing a server error.

3. Final Answer:

   Deleting item without checking if it exists -> Option D

4. Quick Check:

   Always check existence before deleting [OK]

Hint: Check key exists before deleting to avoid errors [OK]

Common Mistakes:

• Ignoring KeyError on missing keys
• Thinking async def causes error here
• Assuming route path syntax is wrong

5. You want to create a FastAPI endpoint to update an item only if it exists, otherwise return a 404 error. Which code snippet correctly implements this behavior? A:

@app.put("/items/{item_id}")
async def update_item(item_id: int, item: dict):
    items[item_id] = item
    return item

B:

@app.put("/items/{item_id}")
async def update_item(item_id: int, item: dict):
    if item_id not in items:
        return {"error": "Not found"}
    items[item_id] = item
    return item

C:

from fastapi import HTTPException
@app.put("/items/{item_id}")
async def update_item(item_id: int, item: dict):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    items[item_id] = item
    return item

D:

@app.put("/items/{item_id}")
async def update_item(item_id: int, item: dict):
    try:
        items[item_id] = item
    except KeyError:
        return {"error": "Not found"}
    return item

hard

A. Raises HTTPException with 404 status if missing

B. Returns error dict but no HTTP status code change

C. Updates without checking existence, no error if missing

D. Catches KeyError incorrectly, since assignment won't raise it

Solution

1. Step 1: Understand proper 404 error handling in FastAPI

   FastAPI uses HTTPException to return HTTP errors with status codes.

2. Step 2: Analyze each option's error handling

   The snippet using HTTPException(status_code=404, detail="Item not found") correctly returns a 404 response. Others either update without checking (200 OK), return an error dict as 200 OK, or misuse try-except since assignment does not raise KeyError.

3. Final Answer:

   Raises HTTPException with 404 status if missing -> Option A

4. Quick Check:

   Use HTTPException for proper HTTP error responses [OK]

Hint: Use HTTPException to return 404 errors in FastAPI [OK]

Common Mistakes:

• Returning error dict without HTTP status change
• Assuming assignment raises KeyError
• Not raising HTTPException for errors