SQLite is a file-based database engine that allows applications to manage data with a single file. However, it has inherent limitations, especially concerning concurrency. Jellyfin, which has relied on SQLite for data storage, has faced issues where multiple write operations can lead to database locking errors. These errors are particularly problematic because they don't occur consistently, making them hard to diagnose. The blog post outlines how Jellyfin has tackled these concurrency challenges, which can benefit other developers using SQLite. The Write-Ahead-Log (WAL) feature in SQLite allows for multiple parallel writes. Still, it doesn't eliminate all locking conflicts. Transactions in SQLite can block other operations, leading to database locks. Jellyfin has experienced issues where the SQLite engine reports a locked database during transactions, causing crashes instead of waiting for resolution. The problems stem from how Jellyfin previously managed parallel tasks, leading to excessive write requests that SQLite struggles to handle. To address these issues, Jellyfin transitioned to EF Core, which allows for better control over database operations through interceptors. The team implemented three locking strategies: No-Lock, Optimistic locking, and Pessimistic locking. No-Lock is the default and assumes no issues during writes. Optimistic locking retries failed operations a set number of times, while Pessimistic locking ensures that only one write operation occurs at a time, blocking all others. Initial tests indicate that these strategies improve stability and reduce the chance of locking errors, providing users with a more reliable experience.