Rust web development still feels awkward before shipping, cot.rs says

A small routing mistake in async Rust can disappear inside a backtrace with around 100 frames before a new web app ever reaches its first deploy. In their June 25, 2026 look at the web stack around cot.rs, Mateusz Maćkowski and Marek Grzelak argue that the pain is not that Rust cannot ship; every new app still feels like a fresh assembly project. Their answer is a more batteries-included approach, aimed at making the repeat work less repetitive.

What still feels awkward

The first friction point is the same one many Rust web teams hit as soon as they move from a toy API to a real service: too much glue. Maćkowski and Grzelak describe a pattern of building JSON APIs where each new project means re-picking libraries, rewiring the same setup, and solving the same integration problems again. Rust can make that work precise, but not necessarily fast.

Async Rust is part of the tradeoff. It gives you powerful concurrency and strong correctness guarantees, yet the debugging experience can still be brutal when a failure is buried inside a backtrace. That kind of stack trace depth can turn a small routing mistake into an afternoon of spelunking. For teams shipping customer-facing services, the issue is not whether Rust can express the logic, but how long it takes to isolate where the logic actually broke.

Where the stack still leaks complexity

ORMs and schema management remain one of the most concrete pain points. The authors point to the annoyance of keeping the same schema in multiple places, which is why declarative migrations keep drawing interest in Rust web circles. SeaORM leans directly into that need, with a dedicated migration system for creating tables, modifying schemas, and seeding data, plus an entity-first workflow in 2.0 that can detect schema changes and generate new tables, columns, and keys.

Error handling is another place where the abstraction layer still shows its seams. In axum, if you are only using async functions as handlers, you do not have to think much about errors, but once you embed general Services or add middleware that can fail, you have to tell axum how to convert those errors into responses. That extra wiring is exactly the kind of app-wide behavior that feels simple in the abstract and fiddly in a production service, especially when different parts of the stack handle failures differently.

Macros help Rust web developers write less boilerplate, but they also create one of the language’s classic tradeoffs. When they fail, they can expand into huge generated codebases that are hard to inspect, which makes the problem feel much larger than the original line of code. In practice, that means a debugging session can shift from your source file to the macro expansion model itself, and that is still a steep ask for teams that want to move quickly.

Why compile times still matter

The Rust project has been hearing the same complaint from developers for years: long compile times are a productivity killer. That is why it launched a compiler performance survey on June 16, 2025, and why the response count mattered so much, with more than 3,700 responses by September 2025.

The push toward opinionated frameworks

Loco.rs is a productivity-first fullstack Rust framework and compares itself to Ruby on Rails for Rust. cot.rs takes a similar position from a different angle, describing itself as inspired by Django’s developer-friendly approach. Both point the same way: the community is not asking Rust to become less capable; it is asking for more integrated defaults, clearer opinions, and fewer decisions that have to be remade for every new service.

The freedom Rust gives experienced developers can overwhelm teams that want a Rails or Django-style starting point. The difference is not philosophical, it is practical: fewer moving parts at the beginning means less time spent routing around framework churn, and more time spent on the actual app. cot.rs’ own GitHub activity in 2026 shows continued appetite for higher-level scaffolding.

Rust is already in the places that feel these costs most

Cloudflare uses Rust in production systems including Pingora and a Rust-based request handling layer, and AWS announced in November 2025 that Rust support in Lambda had become generally available. Rust web ergonomics matter in production environments where request paths, deploy cadence, and developer iteration time all feed directly into real delivery costs.