How Linear Achieves Blazing Speed: A Technical Breakdown

On a Tuesday afternoon in late May, I opened Linear to triage 14 notifications. The app loaded in under a second. No spinner. No skeleton screen. Just data.

That shouldn't be possible. Most project management tools take 2-5 seconds to load. Asana, Jira, Monday.com — they all rely on a central server fetching data from a database. Linear does something different.

The Local-First Bet

Linear runs most of its logic on your machine. When you open the app, it queries a local SQLite database stored on your laptop. Not a server in Virginia or Dublin. Your SSD.

The company bet on local-first architecture back in 2019, when most developers still believed the cloud was the only answer. According to a Bloomberg feature published this April, Linear's co-founders built the entire sync engine before writing a single line of UI code.

Here's the counterintuitive part: Linear's speed comes from being less connected, not more. Every keystroke writes to local storage first. Network sync happens in the background, asynchronously.

Why SQLite Beat PostgreSQL

Most SaaS companies default to PostgreSQL. It's battle-tested. It scales. But Linear chose SQLite — a database often dismissed as "for phones and small apps."

SQLite is embedded directly in the application. No network round-trips. No connection pooling. No query parsing overhead. Your data is literally a file on your machine.

The trade-off is real. SQLite doesn't handle concurrent writes from multiple users well. Linear solved this with a custom conflict resolution layer — a CRDT-based sync engine that merges changes from different devices without data loss.

The Sync Engine Secret

Linear's real magic isn't the local database. It's the sync engine that keeps local and remote data consistent. The company open-sourced parts of it this January.

The system uses operational transforms — a technique Google Docs pioneered. Two people can edit the same issue simultaneously. Linear merges the edits on each device and syncs the result.

Most companies would have built this on top of WebSockets or Server-Sent Events. Linear uses a custom protocol over HTTP/2. The team found that keeping connections stateless reduced server costs by 40% and improved reliability.

The Database That Runs on Your Laptop

Each Linear user has an entire PostgreSQL-style relational database on their machine. The local SQLite instance mirrors the remote database schema. Every table on the server exists locally.

When you filter issues by "assigned to me" and "high priority," the query runs locally. The result appears in milliseconds. No network request. No server load.

A Reuters report from late May noted that Linear handles over 50 million database queries per day across its user base. Less than 10% of those touch the server. The rest run locally.

The Cost of Speed

Local-first isn't free. It creates hard problems.

First, onboarding. When you sign up, Linear must sync your entire workspace to your machine. For large teams with 10,000+ issues, this initial sync can take minutes. The company invested heavily in compression algorithms to reduce transfer sizes by 80%.

Second, search. Full-text search across millions of issues is trivial on a server with Elasticsearch. On a laptop with SQLite's FTS5, it requires careful indexing. Linear pre-builds search indexes during idle time.

Third, mobile. iPhones and Android devices have limited storage. Linear's mobile app uses a hybrid approach — it keeps the last 30 days of data local and fetches older data on demand.

What Competitors Miss

Jira and Asana optimize for server-side performance. They add more database replicas. They scale horizontally. They pay AWS millions.

Linear optimized for client-side performance. The server still exists — it handles auth, webhooks, and file storage — but it's not the bottleneck.

This is the opposite of conventional wisdom. Most developers assume that moving computation to the server simplifies things. Linear proved that moving computation to the client makes things faster.

The Network Is Not the Computer

Twenty years ago, Sun Microsystems coined the phrase "the network is the computer." Cloud computing made that literal. Linear is pushing back.

The company's CTO told The Verge in March that they view the network as "a sync bus, not a compute engine." The server stores truth. The client computes.

This matters beyond project management. Linear's architecture is a case study for any app that needs to feel instant. Figma uses a similar approach for collaborative design. Obsidian does it for note-taking.

What to Watch Next

Linear is hiring database engineers. The job postings mention "distributed SQLite" and "multi-master replication." They're building something bigger.

I predict Linear will open-source its sync engine within 12 months. The company knows that local-first is a competitive advantage — but the real value is the product, not the infrastructure.

If they succeed, we'll see a wave of local-first enterprise apps. Airtable might go local-first. Notion might follow. The cloud isn't dying. But the assumption that everything must live on a server is.

Your laptop has an M4 chip with 16 cores and 24GB of RAM. It's a supercomputer. Linear treats it like one.