Question 1

How would you design a Python service to handle 10,000 concurrent HTTP requests efficiently?

Accepted Answer

Use async frameworks (FastAPI + asyncio + uvloop), connection pooling for DB, multiple worker processes via Gunicorn + Uvicorn, and horizontal scaling behind a load balancer. FastAPI + Uvicorn: async request handling, sub-millisecond overhead. uvloop: 2–4× faster event loop. asyncpg or SQLAlchemy async for non-blocking DB. Gunicorn spawns N Uvicorn workers (N = CPU cores). Beyond one machine: add more instances behind nginx or an AWS ALB.

Question 2

What are the trade-offs between Celery and asyncio for background task processing?

Accepted Answer

Celery excels for distributed task queues with retries, priorities, scheduling, and persistence across restarts; asyncio is better for lightweight in-process concurrent I/O without the broker overhead. Celery: broker (Redis/RabbitMQ) + worker processes, task visibility, retry policies, ETA scheduling — production-grade distributed tasks. asyncio tasks: fire-and-forget coroutines in the same process, lost on crash. Use Celery for anything that must reliably complete; asyncio for lightweight concurrent I/O within a request.

Question 3

When would you choose Python for a system component versus a compiled language like Go or Rust?

Accepted Answer

Python excels for I/O-bound services, data science, ML/AI pipelines, and rapid prototyping; prefer Go/Rust for CPU-intensive, low-latency, or memory-constrained components. Python wins: ML/AI ecosystem (PyTorch, TensorFlow), data pipelines, REST APIs with async I/O, scripting. Go/Rust win: system tools, high-throughput proxies, real-time systems, CLI tools. Polyglot architectures are normal — use the right tool per component.

Question 4

How would you implement a distributed rate limiter in Python for a multi-instance API?

Accepted Answer

Use Redis with a sliding window or token bucket algorithm — Lua scripts or the Redis Cell (INCR + EXPIRE) module ensure atomic cross-instance rate limiting with O(1) operations. In-memory counters don't work across instances. Redis solution: INCR key; EXPIRE key window_seconds. Or sliding window: sorted set with timestamps. Redis Lua scripts execute atomically. Libraries like slowapi (FastAPI) or flask-limiter wrap this pattern. Redis cluster handles high throughput.

Question 5

How would you approach optimizing a Python service that is identified as CPU-bound?

Accepted Answer

Profile first (cProfile, py-spy), then consider: NumPy vectorization, Cython for hot paths, multiprocessing for parallelism, or rewriting only the bottleneck in Rust/C with cffi or pybind11. 80/20 rule: 20% of code uses 80% of time. Profile first — never optimize blind. NumPy eliminates Python loops for numeric work. Cython compiles Python-like code to C. For true parallelism: multiprocessing. For maximum performance: write a tiny C extension. Avoid premature rewrite.

Python — Tech Lead Interview Questions

More Tech Lead Topics

Python at Other Levels