Python 3.13 vs. TypeScript 5.6: API Development Speed and Error Rate Benchmarks for 2026 Backend Projects

"""Python 3.13 User Management API
Uses FastAPI 0.115.0, Pydantic v3.0.0rc2, Python 3.13.0rc1
Benchmarks run on AWS t4g.2xlarge (8 vCPU, 32GB RAM)"""

import contextlib
import logging
import uuid
from collections.abc import AsyncIterator
from typing import Annotated

from fastapi import FastAPI, HTTPException, Request, status
from fastapi.responses import JSONResponse
from pydantic import BaseModel, EmailStr, Field, ValidationError

# Python 3.13 PEP 695 type parameter syntax for generic responses
type Response[T] = dict[str, T | None] | dict[str, str]

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# In-memory store for demo (use Redis/Postgres in prod)
user_store: dict[uuid.UUID, "User"] = {}

class UserBase(BaseModel):
    email: EmailStr
    first_name: str = Field(min_length=1, max_length=50)
    last_name: str = Field(min_length=1, max_length=50)

class UserCreate(UserBase):
    password: str = Field(min_length=12, max_length=64)

class User(UserBase):
    id: uuid.UUID
    is_active: bool = True

    # Python 3.13 improved model validation performance
    model_config = {"str_strip_whitespace": True}

class UserUpdate(BaseModel):
    first_name: str | None = Field(default=None, min_length=1, max_length=50)
    last_name: str | None = Field(default=None, min_length=1, max_length=50)
    is_active: bool | None = None

app = FastAPI(title="Python 3.13 User API", version="1.0.0")

@contextlib.asynccontextmanager
async def lifespan(app: FastAPI) -> AsyncIterator[None]:
    """Python 3.13 improved async context manager support"""
    logger.info("Starting up Python 3.13 API...")
    yield
    logger.info("Shutting down Python 3.13 API...")

app.router.lifespan_context = lifespan

@app.exception_handler(ValidationError)
async def validation_exception_handler(request: Request, exc: ValidationError) -> JSONResponse:
    """Catch Pydantic validation errors and return 422"""
    logger.warning(f"Validation error: {exc.errors()}")
    return JSONResponse(
        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
        content={"detail": exc.errors(), "message": "Invalid request payload"},
    )

@app.post("/users", response_model=Response[User])
async def create_user(user: UserCreate) -> Response[User]:
    """Create a new user with password hashing (simplified for demo)"""
    user_id = uuid.uuid4()
    # In prod: hash password with bcrypt/argon2
    new_user = User(
        id=user_id,
        email=user.email,
        first_name=user.first_name,
        last_name=user.last_name,
    )
    user_store[user_id] = new_user
    logger.info(f"Created user {user_id}")
    return {"data": new_user, "message": "User created successfully"}

@app.get("/users/{user_id}", response_model=Response[User])
async def get_user(user_id: uuid.UUID) -> Response[User]:
    """Retrieve a user by ID"""
    if user_id not in user_store:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=f"User {user_id} not found",
        )
    return {"data": user_store[user_id], "message": "User retrieved successfully"}

@app.patch("/users/{user_id}", response_model=Response[User])
async def update_user(user_id: uuid.UUID, update: UserUpdate) -> Response[User]:
    """Update user fields partially"""
    if user_id not in user_store:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=f"User {user_id} not found",
        )
    current_user = user_store[user_id]
    update_data = update.model_dump(exclude_unset=True)
    for key, value in update_data.items():
        setattr(current_user, key, value)
    user_store[user_id] = current_user
    logger.info(f"Updated user {user_id}")
    return {"data": current_user, "message": "User updated successfully"}

if __name__ == "__main__":
    import uvicorn
    # Python 3.13 JIT enabled by default in 3.13.0rc1
    uvicorn.run(app, host="0.0.0.0", port=8000)

/** TypeScript 5.6 User Management API
 * Uses Fastify 5.1.0, TypeBox 0.33.0, TypeScript 5.6.3
 * Benchmarks run on AWS t4g.2xlarge (8 vCPU, 32GB RAM)
 */

import Fastify, { FastifyRequest, FastifyReply } from "fastify";
import { Type, Static } from "@sinclair/typebox";
import { Value } from "@sinclair/typebox/value";
import { randomUUID } from "node:crypto";
import { IncomingMessage, ServerResponse } from "node:http";

// TypeScript 5.6 exactOptionalPropertyTypes enabled in tsconfig
// Strict null checks enforced by default

// TypeBox schemas (generated from TypeScript types for runtime validation)
const UserBase = Type.Object({
  email: Type.String({ format: "email" }),
  firstName: Type.String({ minLength: 1, maxLength: 50 }),
  lastName: Type.String({ minLength: 1, maxLength: 50 }),
});

const UserCreate = Type.Composite([
  UserBase,
  Type.Object({
    password: Type.String({ minLength: 12, maxLength: 64 }),
  }),
]);

const User = Type.Composite([
  UserBase,
  Type.Object({
    id: Type.String({ format: "uuid" }),
    isActive: Type.Boolean({ default: true }),
  }),
]);

const UserUpdate = Type.Partial(
  Type.Object({
    firstName: Type.String({ minLength: 1, maxLength: 50 }),
    lastName: Type.String({ minLength: 1, maxLength: 50 }),
    isActive: Type.Boolean(),
  })
);

// Infer TypeScript types from TypeBox schemas (single source of truth)
type TUserBase = Static;
type TUserCreate = Static;
type TUser = Static;
type TUserUpdate = Static;

// In-memory store for demo (use Redis/Postgres in prod)
const userStore: Map = new Map();

// Initialize Fastify with TypeScript 5.6 strict type checking
const fastify = Fastify({
  logger: true,
  ajv: { customOptions: { allErrors: true } },
});

// Global error handler for validation errors
fastify.setErrorHandler((error, request, reply) => {
  if (error.validation) {
    reply.status(422).send({
      detail: error.validation,
      message: "Invalid request payload",
    });
    return;
  }
  fastify.log.error(error);
  reply.status(500).send({ message: "Internal server error" });
});

// POST /users - Create new user
fastify.post<{
  Body: TUserCreate;
  Reply: { data: TUser | null; message: string };
}>(
  "/users",
  {
    schema: {
      body: UserCreate,
      response: {
        200: Type.Object({
          data: Type.Union([User, Type.Null()]),
          message: Type.String(),
        }),
      },
    },
  },
  async (request, reply) => {
    const user = request.body;
    const userId = randomUUID();
    // In prod: hash password with bcrypt/argon2
    const newUser: TUser = {
      id: userId,
      email: user.email,
      firstName: user.firstName,
      lastName: user.lastName,
      isActive: true,
    };
    userStore.set(userId, newUser);
    fastify.log.info(`Created user ${userId}`);
    reply.status(201).send({ data: newUser, message: "User created successfully" });
  }
);

// GET /users/:userId - Retrieve user by ID
fastify.get<{
  Params: { userId: string };
  Reply: { data: TUser | null; message: string };
}>(
  "/users/:userId",
  {
    schema: {
      params: Type.Object({ userId: Type.String({ format: "uuid" }) }),
      response: {
        200: Type.Object({
          data: Type.Union([User, Type.Null()]),
          message: Type.String(),
        }),
      },
    },
  },
  async (request, reply) => {
    const { userId } = request.params;
    if (!userStore.has(userId)) {
      reply.status(404).send({ data: null, message: `User ${userId} not found` });
      return;
    }
    const user = userStore.get(userId)!;
    reply.send({ data: user, message: "User retrieved successfully" });
  }
);

// PATCH /users/:userId - Update user partially
fastify.patch<{
  Params: { userId: string };
  Body: TUserUpdate;
  Reply: { data: TUser | null; message: string };
}>(
  "/users/:userId",
  {
    schema: {
      params: Type.Object({ userId: Type.String({ format: "uuid" }) }),
      body: UserUpdate,
      response: {
        200: Type.Object({
          data: Type.Union([User, Type.Null()]),
          message: Type.String(),
        }),
      },
    },
  },
  async (request, reply) => {
    const { userId } = request.params;
    if (!userStore.has(userId)) {
      reply.status(404).send({ data: null, message: `User ${userId} not found` });
      return;
    }
    const currentUser = userStore.get(userId)!;
    const updates = request.body;
    // TypeScript 5.6 exactOptionalPropertyTypes ensures no undefined assignment
    const updatedUser: TUser = { ...currentUser, ...updates };
    userStore.set(userId, updatedUser);
    fastify.log.info(`Updated user ${userId}`);
    reply.send({ data: updatedUser, message: "User updated successfully" });
  }
);

// Start server
const start = async () => {
  try {
    await fastify.listen({ port: 3000, host: "0.0.0.0" });
    fastify.log.info("TypeScript 5.6 API listening on port 3000");
  } catch (err) {
    fastify.log.error(err);
    process.exit(1);
  }
};

if (require.main === module) {
  start();
}

/** Cross-runtime API Benchmark Script
 * Uses k6 0.52.0, tests Python 3.13 and TypeScript 5.6 APIs
 * Hardware: AWS t4g.2xlarge (8 vCPU, 32GB RAM) for both API and k6 runner
 * Benchmark duration: 30 minutes per run, 3 runs averaged
 */

import http from "k6/http";
import { check, sleep, trend, rate } from "k6";
import { randomString } from "https://jslib.k6.io/k6-utils/1.4.0/index.js";

// Benchmark metrics
const rtTrend = new trend("response_time");
const errorRate = new rate("error_rate");
const pythonApiUrl = "http://python-api:8000";
const tsApiUrl = "http://typescript-api:3000";

// Test configuration
export const options = {
  stages: [
    { duration: "5m", target: 500 }, // Ramp up to 500 users
    { duration: "20m", target: 500 }, // Stay at 500 users
    { duration: "5m", target: 0 }, // Ramp down
  ],
  thresholds: {
    "response_time": ["p(95)<200"], // 95% of requests under 200ms
    "error_rate": ["rate<0.01"], // Less than 1% errors
  },
};

// Helper to generate random user payload
function generateUserPayload() {
  return {
    email: `test-${randomString(8)}@example.com`,
    first_name: `First${randomString(6)}`,
    last_name: `Last${randomString(6)}`,
    password: `Pass${randomString(12)}!`,
  };
}

export default function () {
  // Alternate between Python and TypeScript APIs for fair comparison
  const isPython = Math.random() > 0.5;
  const baseUrl = isPython ? pythonApiUrl : tsApiUrl;
  const apiLabel = isPython ? "Python 3.13" : "TypeScript 5.6";

  // 1. Create user
  const createPayload = generateUserPayload();
  const createRes = http.post(`${baseUrl}/users`, JSON.stringify(createPayload), {
    headers: { "Content-Type": "application/json" },
    tags: { api: apiLabel, endpoint: "create_user" },
  });

  // Check create response
  const createCheck = check(createRes, {
    "create user status is 200/201": (r) => r.status === 200 || r.status === 201,
    "create user returns id": (r) => JSON.parse(r.body).data?.id !== undefined,
  });
  rtTrend.add(createRes.timings.duration, { api: apiLabel, endpoint: "create_user" });
  errorRate.add(!createCheck, { api: apiLabel, endpoint: "create_user" });

  if (!createCheck) {
    sleep(1);
    return;
  }

  const userId = JSON.parse(createRes.body).data.id;

  // 2. Get user
  const getRes = http.get(`${baseUrl}/users/${userId}`, {
    tags: { api: apiLabel, endpoint: "get_user" },
  });
  const getCheck = check(getRes, {
    "get user status is 200": (r) => r.status === 200,
    "get user id matches": (r) => JSON.parse(r.body).data?.id === userId,
  });
  rtTrend.add(getRes.timings.duration, { api: apiLabel, endpoint: "get_user" });
  errorRate.add(!getCheck, { api: apiLabel, endpoint: "get_user" });

  // 3. Update user
  const updatePayload = { first_name: `Updated${randomString(4)}` };
  const updateRes = http.patch(`${baseUrl}/users/${userId}`, JSON.stringify(updatePayload), {
    headers: { "Content-Type": "application/json" },
    tags: { api: apiLabel, endpoint: "update_user" },
  });
  const updateCheck = check(updateRes, {
    "update user status is 200": (r) => r.status === 200,
    "update user first name matches": (r) =>
      JSON.parse(r.body).data?.first_name === updatePayload.first_name,
  });
  rtTrend.add(updateRes.timings.duration, { api: apiLabel, endpoint: "update_user" });
  errorRate.add(!updateCheck, { api: apiLabel, endpoint: "update_user" });

  sleep(1); // Wait 1s between iterations
}

export function handleSummary(data: any) {
  // Log summary to console and write to JSON file
  return {
    "benchmark-summary.json": JSON.stringify(data, null, 2),
    stdout: textSummary(data, { indent: "  " }),
  };
}

// Helper to format text summary (simplified for demo)
function textSummary(data: any, options: { indent: string }) {
  const indent = options.indent;
  let summary = `${indent}Benchmark Summary
`;
  summary += `${indent}====================
`;
  for (const [key, value] of Object.entries(data.metrics)) {
    summary += `${indent}${key}: ${JSON.stringify(value)}
`;
  }
  return summary;
}