Sync vs Async Boundaries

// Python 3.10+ FastAPI HTTP 202 Async Task Dispatcher
from fastapi import FastAPI, Header, HTTPException, status
import uuid, json

app = FastAPI()

@app.post("/api/v1/videos/transcode", status_code=status.HTTP_202_ACCEPTED)
async def transcode_video(payload: dict, idempotency_key: str = Header(...)):
    # 1. Idempotency Check: Prevent duplicate jobs on client network retry
    cached_job = await redis.get(f"idem:{idempotency_key}")
    if cached_job:
        return json.loads(cached_job)

    # 2. Generate unique Job ID and push to Task Queue (SQS / Redis)
    job_id = f"job_{uuid.uuid4().hex[:8]}"
    job_info = {"job_id": job_id, "status": "QUEUED", "status_url": f"/api/v1/jobs/{job_id}"}
    
    await redis.set(f"idem:{idempotency_key}", json.dumps(job_info), ex=86400)
    await task_queue.enqueue("video_transcode", {"job_id": job_id, "payload": payload})

    # 3. Return HTTP 202 Accepted in under 5ms!
    return job_info

// C++20 Crow HTTP 202 Controller
#include <crow.h>

void handleTranscode(const crow::request& req, crow::response& res) {
    std::string idemKey = req.get_header_value("Idempotency-Key");
    if (redis->exists("idem:" + idemKey)) {
        res.code = 202;
        res.write(redis->get("idem:" + idemKey));
        res.end();
        return;
    }
    std::string jobId = generateUuid();
    taskQueue->push("video_transcode", req.body, jobId);
    crow::json::wvalue resp;
    resp["job_id"] = jobId;
    resp["status"] = "QUEUED";
    res.code = 202; // HTTP 202 Accepted
    res.write(resp.dump());
    res.end();
}

// Java Spring Boot HTTP 202 Controller
@RestController
public class TaskController {
    @PostMapping("/api/jobs/export")
    public ResponseEntity<JobResponse> createExportJob(
            @RequestHeader("Idempotency-Key") String idemKey,
            @RequestBody ExportRequest req) {
        
        String jobId = "job_" + UUID.randomUUID().toString().substring(0, 8);
        rabbitTemplate.convertAndSend("task_exchange", "export_key", req);
        
        JobResponse resp = new JobResponse(jobId, "QUEUED", "/api/jobs/" + jobId);
        return ResponseEntity.status(HttpStatus.ACCEPTED).body(resp);
    }
}

// Go Gin HTTP 202 Handler
package main

import (
    "github.com/gin-gonic/gin"
    "net/http"
)

func TranscodeHandler(c *gin.Context) {
    jobId := generateJobId()
    // Enqueue async task to Redis channel
    redisClient.LPush(c, "task_queue:video", jobId)
    
    c.JSON(http.StatusAccepted, gin.H{
        "job_id":     jobId,
        "status":     "ACCEPTED",
        "status_url": "/api/jobs/" + jobId,
    })
}

// TypeScript Express HTTP 202 Async Route
app.post('/api/jobs/pdf', async (req: Request, res: Response) => {
    const idemKey = req.headers['idempotency-key'] as string;
    const existing = await redis.get(`idem:${idemKey}`);
    if (existing) return res.status(202).json(JSON.parse(existing));

    const jobId = `job_${nanoid(8)}`;
    await sqsQueue.send({ jobId, payload: req.body });
    
    const payload = { jobId, status: 'QUEUED', checkUrl: `/api/jobs/${jobId}` };
    await redis.set(`idem:${idemKey}`, JSON.stringify(payload), 'EX', 86400);
    
    return res.status(202).json(payload);
});