The author argues that many transactional databases would benefit from being single-threaded and aggressively sharded. Traditional SQL databases, like Postgres, face significant challenges due to row-level locking and transaction modes that can lead to deadlocks and unpredictable race conditions, especially under high load. With different transaction modes—READ COMMITTED, REPEATABLE READ, and SERIALIZABLE—developers often struggle to implement them correctly, leading to a high rate of failures and performance bottlenecks. The author suggests that these issues stem primarily from conflicting writes. By ensuring a single writer is responsible for all writes at any given time, databases could maintain perfect ordering without the complexities of managing multiple locks. SQLite is mentioned as an example that operates on this principle but has its own limitations, particularly in terms of scalability since it can only handle one write operation at a time. Sharding, a common solution for scaling, introduces its own set of complexities, such as difficulties with cross-shard queries and maintaining transactional integrity across shards. For transactions, the author presents alternative strategies like optimistic concurrency and sagas, which can mitigate issues when transferring data between shards. On migration challenges, the discussion outlines different approaches depending on whether downtime is acceptable. The piece emphasizes that while sharding can be beneficial, it requires careful planning and the right tools to manage the inherent complications effectively.