TL;DR
Linear updates issues in a few milliseconds by using a local IndexedDB database and a custom sync engine that eliminates network latency. This approach makes the app feel instant and highly responsive. The article analyzes the technical foundations enabling this performance.
Linear can update issues in just a few milliseconds, a significant improvement over traditional CRUD applications that typically take around 300 milliseconds. This performance is achieved through a combination of in-browser database use and a custom sync engine, making the app feel instant and highly responsive.
Linear’s core innovation lies in placing the database within the browser using IndexedDB, allowing local mutations to be applied immediately without waiting for server confirmation. When a user updates an issue, the change is reflected instantly in the UI, with the sync engine batching and asynchronously pushing updates to the server in the background. This design eliminates network latency as a bottleneck, providing a seamless experience.
The sync engine, developed from the start by Linear’s co-founders, manages local state and server synchronization efficiently, enabling updates to be nearly instantaneous. The approach contrasts with standard web apps, which often rely on optimistic updates with libraries like SWR or Tanstack Query, but still depend on network responses for confirmation. Linear’s architecture prioritizes local-first data handling, making the UI feel native and fast.
Why It Matters
This technical approach fundamentally changes user experience expectations for web applications by demonstrating that instant responsiveness is achievable at scale. It also influences how developers might design future web apps, emphasizing local data storage and background synchronization to improve perceived performance and reduce loading states.
IndexedDB Architecture and Programming: The Complete Guide for Developers and Engineers
As an affiliate, we earn on qualifying purchases.
As an affiliate, we earn on qualifying purchases.
Background
Traditional web apps depend heavily on server round-trips for data updates, leading to noticeable delays. Linear’s approach, pioneered by their in-browser database and custom sync engine, addresses this bottleneck. They have built their stack with React, TypeScript, MobX, and PostgreSQL, focusing on client-side rendering and local-first data management. This strategy aligns with broader trends toward edge computing and real-time collaboration tools.
“Literally the first lines of code that I wrote was the sync engine, which is very uncommon to what you usually do when you’re a startup.”
— Tuomas, Linear co-founder
“The secret to building incredible web apps is by hiding all the network requests from the user.”
— Dennis Brotzky, author
Local-First Software: Offline-Ready Apps, Sync Engines, Conflict Resolution, and User Control
As an affiliate, we earn on qualifying purchases.
As an affiliate, we earn on qualifying purchases.
What Remains Unclear
It is not yet clear how Linear’s architecture performs under extremely high concurrency or with large datasets. Details about the scalability limits of their local database and sync engine are still emerging.
WebAssembly and Emscripten for High-Performance Web Apps: Practical Techniques and Real-World Projects
As an affiliate, we earn on qualifying purchases.
As an affiliate, we earn on qualifying purchases.
What’s Next
Next steps include further technical disclosures from Linear about their architecture, potential open-sourcing of parts of their sync engine, and observing how their approach influences broader web app development trends. Monitoring their performance in larger-scale deployments will also be key.
Electronics Telemetry Processing: A Complete Guide to Data Acquisition, Signal Processing, Wireless Telemetry, and Real-Time Monitoring Systems
As an affiliate, we earn on qualifying purchases.
As an affiliate, we earn on qualifying purchases.
Key Questions
How does Linear achieve such fast issue updates?
Linear uses an in-browser IndexedDB database and a custom sync engine that applies local mutations immediately and synchronizes with the server asynchronously, eliminating network latency as a bottleneck.
Can this approach be used in other web apps?
Yes, but it requires significant custom development and architecture planning. Most apps can approximate this responsiveness with optimistic updates, but Linear’s fully local-first approach offers near-instant updates at scale.
What are the potential limitations of Linear’s architecture?
The scalability of their local database and sync engine under high concurrency or large datasets remains unconfirmed. Further technical details are needed to assess long-term performance.
Does this architecture impact initial load times?
Linear’s choice of client-side rendering with a simple stack allows for fast initial loads despite the complex local-first data management, but detailed performance metrics are not publicly available.
Source: Hacker News
