FastAPI can be a better fit than Tornado when a team’s main job is building typed, documented HTTP APIs. That does not make it universally faster or a drop-in replacement. The original article reports that Reblaze switched from Tornado to FastAPI for performance, simpler development, validation, documentation, dependency injection, and ecosystem reasons—but it publishes no reproducible benchmark or detailed migration results. The useful lesson is to match the framework to the workload, not to treat one company’s choice as a universal upgrade.
First, what are Tornado and FastAPI?
They overlap, but they are not simply two interchangeable REST frameworks. Tornado is an asynchronous networking library and web framework with its own HTTP server and event-loop model. FastAPI is a higher-level framework for building APIs on ASGI, using Starlette for web capabilities and Pydantic for data parsing and validation. Tornado’s documentation, FastAPI’s documentation, Starlette, and Pydantic describe those roles.
As an Amazon Associate I earn from qualifying purchases.
One important correction: Tornado is not built on WSGI. It has its own asynchronous HTTP server and event-loop architecture. ASGI is the interface used by FastAPI and compatible servers; WSGI is a separate Python web-server interface. The distinction affects server integration, middleware, and deployment assumptions, so a migration is not merely a matter of changing route syntax. See the ASGI specification and WSGI specification.
The Tool Desk
Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Tornado: control over connections and asynchronous behavior
Tornado’s RequestHandler model and HTTP server suit applications that need direct control over asynchronous request handling. It is a serious option for long-lived connections, WebSockets, streaming, long polling, or networking-oriented services. That flexibility means a team often assembles its own conventions for validation, serialization, API documentation, shared request logic, and error formats.
#1 Best Overall
FastAPI: conventions for typed HTTP APIs
FastAPI centers on declaring routes and data contracts with Python annotations and Pydantic models. It can validate request data, generate OpenAPI schemas, expose interactive API documentation, and use dependencies for shared concerns such as authentication or database sessions. Those features are useful when consistency and an explicit API contract matter across many endpoints. They do not remove the need to review the contract against actual runtime behavior.
Why did the team switch?
The original Reblaze article says the team moved from Tornado to FastAPI because it expected better performance and simpler development, and valued validation, generated documentation, dependency injection, and FastAPI’s ecosystem. Those are the authors’ stated reasons. The article does not provide before-and-after latency or throughput figures, a benchmark setup, endpoint count, migration timeline, developer-hours saved, incident data, or a detailed account of which Tornado features were replaced.
That makes the switch a team-specific engineering decision, not proof that FastAPI is faster, cheaper, or easier for every service. The most generalizable rationale is the API-development workflow: a team that wants declarative validation and generated contracts may save effort by adopting a framework that provides those conventions directly.
How do the frameworks compare in practice?
| Concern | Tornado | FastAPI |
|---|---|---|
| Core role | Asynchronous networking library and web framework | Higher-level API framework built on ASGI |
| Request routing | RequestHandler-oriented routing |
Path-operation functions with declared parameters and models |
| Input validation | Team selects or builds validation conventions | Pydantic-backed validation is part of the usual workflow |
| OpenAPI documentation | Typically requires additional tooling or explicit maintenance | Generated from routes, models, and metadata |
| Shared request logic | Application convention or third-party choice | Built-in dependency mechanism |
| WebSockets | Supported; a strong fit for connection-oriented applications | Supported through FastAPI and Starlette; migration behavior still needs testing |
| Streaming | Supported | Supported through response mechanisms; implementation and lifecycle differ |
| Performance verdict | Must be measured for the actual workload | Must be measured for the actual workload |
FastAPI’s request-body, response-model, dependency, and metadata documentation shows how the API-specific workflow fits together. Python annotations alone do not perform runtime validation; the framework’s model and request-processing machinery do that work.
Does FastAPI perform better?
The original article’s performance claim cannot be generalized from the evidence it publishes. It provides no reproducible method, workload description, server configuration, or results table. Both frameworks can support asynchronous I/O, but async syntax does not establish that one will serve more requests or connections in a particular system.
Results depend on more than framework choice: database and external-service latency, serialization and validation costs, blocking code, worker and server configuration, payload size, and connection behavior can dominate. FastAPI’s validation and serialization have runtime costs, which may be worthwhile if they reduce application bugs and custom code. Tornado’s direct control may be valuable when connection handling is central. Neither observation substitutes for measurement.
Benchmark the behavior you intend to run
Use the same hardware, Python and dependency versions, data, server conditions, and deployment topology. Measure throughput, median and tail latency, error rates, and memory—not just a single requests-per-second figure. Include the application paths that matter:
Free tools Windows power users keep installed
One-click scans. No signup required.
- A minimal JSON response, to estimate baseline overhead.
- Typed request validation, including large or nested payloads and invalid inputs.
- A database-backed endpoint and an endpoint that makes concurrent outbound requests.
- WebSocket echo or broadcast behavior, including memory under many idle connections if persistent connections are important.
- Streaming, error responses, and the real authentication and middleware stack.
A synthetic “hello world” test can help isolate a narrow baseline, but it cannot predict a database-bound API or a connection-heavy service. Async I/O improves efficiency while waiting; it does not make CPU-bound work execute in parallel.
What FastAPI adds to API development
Validation and response contracts
Models can define expected request data and contribute to generated schemas. Response models can also describe and filter output, but only if they accurately reflect what the application returns. Custom or direct responses can bypass parts of the standard model workflow; a generated schema is not a substitute for contract tests. FastAPI documents request bodies, response models, and direct responses.
Teams should pay particular attention to coercion and strictness, optional versus nullable fields, nested models, date and enum handling, error formats, large payload cost, and compatibility when schemas change. Runtime validation and static type checking are different tools: a type annotation does not by itself guarantee that incoming JSON satisfies a contract.
OpenAPI documentation
FastAPI can generate an OpenAPI description from route declarations, models, and metadata, enabling interactive documentation such as Swagger UI and ReDoc. The contract is only as accurate as those declarations and the behavior behind them. Review authentication metadata, response codes, error cases, examples, and custom response paths, then test the published contract against the running service. The OpenAPI specification defines the standard format.
Recommended Free Tools
Dependencies and application structure
FastAPI dependencies can centralize authentication, authorization checks, tenant resolution, configuration, pagination, external clients, or per-request database sessions. They are also overridable in tests, as described in the dependency documentation. A dependency mechanism is not a complete application architecture: deep graphs can obscure control flow, resources need correct cleanup, and ordinary function calls do not all need to become dependencies. Tornado teams can implement these patterns too, but they choose and maintain the conventions themselves.
What does a Tornado-to-FastAPI migration involve?
Both ecosystems support asynchronous work, but that does not make a migration mechanical. Audit how much code depends on Tornado’s handlers, clients, decorators, event loop, and connection lifecycle before estimating the work.
- Inventory the existing service. Record routes, request and response formats, error codes, middleware, authentication, background work, startup and shutdown behavior, Tornado-specific clients, and every WebSocket or streaming path.
- Set compatibility tests first. Capture representative success and failure responses, status codes, headers, validation behavior, authentication, timeouts, and client-visible error bodies. Add integration tests for connections and cleanup where applicable.
- Map application components. Replace
RequestHandlerclasses and route declarations with FastAPI path operations where appropriate. Decide how to translate request parsing, response handling, authentication, middleware, and shared logic rather than translating code line by line. - Review asynchronous dependencies. Convert callback-style or Tornado-native code where needed, and choose compatible asynchronous clients and data-access libraries. Tornado’s coroutine and HTTP client documentation and FastAPI’s async guidance describe different integration contexts.
- Test connection and lifecycle behavior. Rebuild WebSocket authentication, disconnect handling, backpressure, heartbeats, timeouts, broadcast state, and graceful shutdown explicitly. Test startup and shutdown using the target server’s lifecycle; ASGI defines these events in its lifespan specification.
- Deploy a narrow slice before replacing the service. Move a bounded API or service behind a clear boundary, monitor errors and latency, and retain a rollback path. FastAPI’s testing documentation covers its testing integration, but production compatibility still needs system-level checks.
Blocking database drivers, filesystem calls, or CPU-heavy functions inside an async def handler can stall the event loop. Use non-blocking libraries for I/O where practical; isolate unavoidable blocking work with an appropriate thread pool, process, queue, or separate service. Async declaration alone does not make blocking work safe.
WebSockets, streaming, and long-lived connections
Connection-heavy requirements can change the decision more than ordinary HTTP routing does. Tornado should remain a serious candidate when persistent WebSockets, real-time fan-out, long polling, streaming, custom connection protocols, or fine-grained event-loop behavior are central to the product.
FastAPI also supports WebSockets and streaming through its ASGI stack, so “Tornado supports it and FastAPI does not” would be wrong. But feature availability is not proof of equivalent operational behavior. Compare connection lifecycle hooks, authentication during upgrade, backpressure, broadcast architecture, disconnect detection, heartbeats, shutdown, reverse-proxy behavior, and shared state for horizontal scaling. See the official documentation for Tornado WebSockets, FastAPI WebSockets, Starlette WebSockets, and FastAPI custom and streaming responses.
Deployment is a separate decision
FastAPI’s ASGI application needs an ASGI server and an operational design; changing frameworks does not automatically improve scaling. Choose and configure the server, worker processes, graceful shutdown, timeouts, health checks, reverse proxy, and WebSocket proxy behavior for the actual workload. FastAPI’s deployment guide, ASGI server guidance, Uvicorn documentation, and Gunicorn documentation are relevant starting points.
Operations also include metrics and tracing, request IDs, dependency pinning, container behavior, autoscaling, and the boundary between in-process background tasks and durable queues. FastAPI, Starlette, Pydantic, and the server have version interactions, so test and pin a compatible set. Scaling remains constrained by workload, state management, database capacity, queueing, and infrastructure.
When should you choose each framework?
Choose FastAPI when
- The service is primarily a JSON/HTTP API.
- Declarative validation and response models would replace repeated custom code.
- Generated OpenAPI contracts are valuable to clients and developers.
- A larger team needs consistent endpoint conventions and testable shared dependencies.
- The service’s current Tornado-specific capabilities are limited or can be isolated without disproportionate risk.
Keep or choose Tornado when
- WebSockets, long-lived connections, streaming, or custom networking are core requirements.
- The team relies on Tornado-specific clients, handlers, or event-loop behavior.
- The existing service is stable and well-tested, with no clear product or operational benefit that justifies migration.
- Direct control over connection behavior matters more than built-in API conventions.
Use a hybrid approach when workloads differ
A service boundary can let existing Tornado networking components remain in place while new conventional APIs use FastAPI. Incremental migration can limit blast radius and make rollback more practical than a big-bang rewrite. This works best when the boundary is real—separate services or clearly separated responsibilities—not when two frameworks are mixed without an operational reason.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Repair Windows errors before they cause bigger problems3Scan for outdated or missing drivers - takes under a minuteOther frameworks may fit different constraints: Starlette offers a lower-level ASGI toolkit; Django REST Framework suits projects already centered on Django; Flask offers a familiar lightweight framework whose API contracts require deliberate assembly; Litestar is another ASGI API framework; and aiohttp combines async HTTP client and server capabilities. Evaluate ecosystem fit and team experience rather than selecting by a generic ranking.
Quick Recap
A decision checklist before migrating
- Is the service primarily an API, or a networking application with persistent connections?
- Which Tornado-specific features does production traffic actually use?
- Are measured bottlenecks in request handling, or in the database, downstream services, serialization, or CPU work?
- Would generated schemas and validation reduce real maintenance work for this team?
- What client-visible contracts—errors, status codes, authentication, and response fields—must remain unchanged?
- Can the migration happen by service or endpoint group, with a tested rollback path?
- Which benchmarks and WebSocket, streaming, shutdown, and failure tests must pass before cutover?
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
