TL;DR
Linear’s speed is driven by its innovative use of an in-browser database, a custom sync engine, and optimistic UI updates. This approach minimizes network delays, making the app feel instant. The article explains these techniques and their impact on performance.
Linear’s issue update operation takes just a few milliseconds, a stark contrast to the 300ms typical of traditional CRUD web apps, thanks to its innovative architecture and design choices.
Linear achieves this speed primarily by storing its database within the browser using IndexedDB, allowing local mutations to be applied instantly without waiting for server responses. Its custom sync engine manages background synchronization with the server, batching updates and broadcasting deltas via WebSocket. This setup enables the UI to update immediately after local changes, eliminating loading spinners and perceived delays. The app leverages optimistic updates, immediately reflecting user actions while asynchronously validating changes in the background. Built on a simple stack—React, TypeScript, MobX, PostgreSQL, and CDN—Linear avoids complex frameworks or edge databases, focusing instead on foundational performance principles. The decision to use client-side rendering further supports instant responsiveness, despite common criticisms of slow initial loads for CSR apps.
Why It Matters
This technical approach allows Linear to deliver a highly responsive user experience, setting a new standard for web app performance. For users, it means faster issue management, less waiting, and a more seamless workflow. For developers and other SaaS providers, it demonstrates that performance gains are achievable through thoughtful architecture rather than reliance on complex or expensive infrastructure.
IndexedDB in-browser database
As an affiliate, we earn on qualifying purchases.
As an affiliate, we earn on qualifying purchases.
Background
Prior to this, most web apps relied heavily on server-side operations, resulting in noticeable delays during data updates. Linear’s approach emerged from a deliberate design choice to prioritize responsiveness, with the company’s co-founder Tuomas stating that the sync engine was the first line of code written, emphasizing its importance from day one. This in-browser database concept aligns with broader trends toward local-first applications, but Linear’s execution is distinguished by its efficiency and simplicity.
“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
WebSocket sync engine
As an affiliate, we earn on qualifying purchases.
As an affiliate, we earn on qualifying purchases.
What Remains Unclear
While the technical principles are clear, specific implementation details of Linear’s sync engine and how it scales with larger datasets remain undisclosed. It is also not confirmed whether similar performance can be replicated in other applications without significant customization.
React TypeScript MobX development tools
As an affiliate, we earn on qualifying purchases.
As an affiliate, we earn on qualifying purchases.
What’s Next
Further technical disclosures from Linear or independent analyses may shed light on potential limitations or scalability concerns. Additionally, other SaaS companies might adopt similar architectures, leading to broader industry shifts toward local-first, high-performance web apps.
client-side rendering performance tools
As an affiliate, we earn on qualifying purchases.
As an affiliate, we earn on qualifying purchases.
Key Questions
How does Linear’s in-browser database improve performance?
By storing data locally in IndexedDB, Linear eliminates network latency for data reads and writes, allowing instant local updates that are synchronized in the background.
What is unique about Linear’s sync engine?
It batches local changes and sends them asynchronously to the server, broadcasting deltas via WebSocket, enabling immediate UI updates without waiting for server confirmation.
Can other apps replicate Linear’s speed?
While the principles can be adopted, replicating Linear’s performance requires a similar architecture and tradeoffs, including local-first data management and custom sync logic.
Does client-side rendering affect initial load times?
Linear’s use of client-side rendering is optimized with simple stacks and CDN delivery, making initial load fast despite common criticisms of CSR apps.
What are potential limitations of this approach?
Scaling large datasets in-browser and maintaining consistency across multiple clients can pose challenges, which are not yet fully detailed publicly.
Source: Hacker News
