Routing: From Web Routes to Decorators
Laravel 12 routes typically live in routes/api.php or routes/web.php. You bind an HTTP verb to a URL pattern and point it to a controller action. FastAPI does something similar, but routes attach directly to handler function definitions using Python decorators.
In PHP 8.3 with Laravel 12, a standard route returning a user model looks like this:
namespace App\Http\Controllers;
use App\Models\User;
use Illuminate\Http\JsonResponse;
class UserController extends Controller
{
public function show(int $id): JsonResponse
{
$user = User::findOrFail($id);
return response()->json($user);
}
}In FastAPI 0.115 running on Python 3.12, you declare the HTTP verb decorator directly above your function. Parameter type hints do the work of casting path variables into integers automatically.
from fastapi import FastAPI, HTTPException, status
from pydantic import BaseModel
app = FastAPI()
@app.get("/users/{user_id}")
async def show_user(user_id: int):
user = await find_user_by_id(user_id)
if not user:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="User not found"
)
return userNotice what happens under the hood. In PHP, unless declare(strict_types=1); is active at the invocation point, passing a string like "42" into an integer-hinted method will silently coerce it. FastAPI rejects non-integer path parameters before your route body executes, returning an HTTP 422 Unprocessable Entity response out of the box.
Request Validation: FormRequests vs Pydantic Models
Laravel relies on FormRequest classes or inline $request->validate() arrays. You write rule strings like 'email' => 'required|email|max:255'. FastAPI relies on Python type annotations combined with Pydantic v2 schemas.
Here is a standard POST request validator in Laravel 12:
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
class StoreUserRequest extends FormRequest
{
public function authorize(): bool
{
return true;
}
public function rules(): array
{
return [
'name' => 'required|string|max:100',
'email' => 'required|email',
'age' => 'nullable|integer|min:18',
];
}
}In FastAPI, you define a class inheriting from pydantic.BaseModel. Fields dictate both the JSON schema and runtime validation rules:
from typing import Optional
from pydantic import BaseModel, EmailStr, Field
class CreateUserSchema(BaseModel):
name: str = Field(..., max_length=100)
email: EmailStr
age: Optional[int] = Field(None, ge=18)
@app.post("/users", status_code=status.HTTP_201_CREATED)
async def create_user(payload: CreateUserSchema):
return {"name": payload.name, "email": payload.email}Here's where PHP developers get tripped up: Pydantic isn't just a validator. It's a data transformer and DTO combined. In Laravel, $request->validated() gives you an associative array. In FastAPI, payload is an instantiated CreateUserSchema object. You access attributes via object notation (payload.name), not dictionary keys.
Dependency Injection: Service Container vs Depends
Laravel's service container is global and automatic. Type-hint a dependency in a controller constructor, and Laravel's reflection container instantiates or retrieves it automatically. FastAPI doesn't use constructor injection on controller classes; it uses function-level dependency injection via fastapi.Depends.
Consider this standard Laravel service injection:
namespace App\Http\Controllers;
use App\Services\PaymentGateway;
use Illuminate\Http\JsonResponse;
class OrderController extends Controller
{
public function __construct(
private readonly PaymentGateway $gateway
) {}
public function process(): JsonResponse
{
$result = $this->gateway->charge(100);
return response()->json(['status' => $result]);
}
}Here's the exact equivalent in FastAPI using Depends:
from fastapi import Depends, FastAPI
class PaymentGateway:
def charge(self, amount: int) -> bool:
return True
def get_payment_gateway() -> PaymentGateway:
return PaymentGateway()
@app.post("/orders")
async def process_order(gateway: PaymentGateway = Depends(get_payment_gateway)):
result = gateway.charge(100)
return {"status": result}Depends accepts a callable—either a function or a class. FastAPI calls it before invoking your endpoint, passes the result into your parameter, and handles scope cleanup automatically. For testing, replacing dependencies is just as clean as Laravel's $this->app->instance():
app.dependency_overrides[get_payment_gateway] = lambda: MockPaymentGateway()Gotchas: The Sync vs Async Event Loop Pitfall
The single biggest issue PHP developers run into with FastAPI is mixing synchronous and asynchronous I/O. PHP (via PHP-FPM) uses a shared-nothing execution model. Every HTTP request gets its own dedicated worker process and memory space that shuts down after responding.
FastAPI runs inside an ASGI server like Uvicorn on a persistent Python process. This means two major gotchas will hurt you if you aren't careful:
- Blocking the async loop: If you declare an endpoint as
async def, every operation inside it must be non-blocking (usingawait). If you call a blocking library inside anasync defroute—like standardrequests.get()or a traditional synchronous MySQL driver—you freeze the single-threaded event loop. Every concurrent user on that Uvicorn worker stalls until that call completes. If you must use synchronous code, declare the endpoint as standarddefwithoutasync. FastAPI automatically offloads synchronous endpoints to a background threadpool. - Persisted state memory leaks: In PHP, declaring a global variable or static property is safe because request termination wipes memory. In FastAPI, variables defined at the module level persist across all HTTP requests for the worker's lifespan. Database sessions must be managed carefully using generator functions with
yieldinsideDependsto guarantee cleanup.
async def get_db():
async with AsyncSessionLocal() as session:
yield session
# Cleanup happens automatically after response generationIf you're building high-throughput microservices that interact with external APIs, FastAPI routinely achieves lower latency (~4ms response times compared to ~30ms in standard framework stack setups). But if your app relies on traditional blocking I/O and SQL queries without async drivers, writing synchronous route handlers or sticking with PHP 8.3 and Laravel 12 is often the wiser path.
