Latest / The CTO Podcast with Fexingo: Technical Leadership, Architecture, and Engineering Org / How Linear Uses Linear Technology to Build Linear
Transcript
- Lucas: If these conversations are useful for what you're building or running, it's worth mentioning that the show stays ad-free because of a small group of listeners who chip in a couple of dollars a month. Buy me a coffee dot com slash fexingo — if you've gotten something out of these episodes, that's genuinely how this keeps going. Luna: Yeah, it's a small thing that makes a real difference. Lucas: So today I want to talk about Linear — the project management tool that a lot of engineering teams use. But what's interesting is how Linear itself is built. It's a product that manages software projects, and the team that built it uses it to manage itself. Dogfooding at its most literal. Luna: Right, and they're famously small. I think they were only seven engineers for a long time, even as the product grew to serve thousands of teams. Lucas: Exactly seven. That's the number that stuck. Seven engineers shipping a tool that competes with Jira, Asana, Monday.com — products backed by hundreds or thousands of developers. So how do you do that? The answer is architecture, and a very deliberate set of trade-offs. Luna: What's the core architectural decision that made it possible? Lucas: I'd say it's the choice to stay on a single TypeScript codebase — no microservices, no polyglot backend. The entire product, frontend and backend, is TypeScript. That means every engineer can work on any part of the stack. No context switching between languages or services. When you only have seven people, that kind of cognitive overhead is lethal. Luna: So it's a monolith in the best sense — not a big ball of mud, but a deliberately unified codebase. Lucas: Right. And the second piece is the sync engine. Linear is a real-time app — when you move a ticket, your teammate sees it instantly. But they didn't build on top of something like Firebase or a WebSocket-heavy custom server. They built a sync layer on SQLite and CRDTs — conflict-free replicated data types. Luna: SQLite on the client? That's interesting. Most real-time apps just push everything through a server. Lucas: That's the traditional model. But Linear's approach is that each client has a local SQLite database. When you make a change, it writes locally first — optimistic update — then syncs the change as a CRDT operation to the server. The server merges it, and other clients pick up the delta. Because CRDTs are mathematically conflict-free, you don't need a central arbiter to resolve edit collisions. Luna: So you get offline support for free, too. If you're on a train with no signal, you can still rearrange your backlog, and it all syncs when you reconnect. Lucas: Exactly. And the team has published some numbers. Their sync latency target is under 50 milliseconds for a typical operation. Most of the time, the local write is instant, and the sync happens in the background. They've also said they've seen zero merge conflicts on issues — that's the CRDT guarantee in action. No 'someone else edited this, please refresh' errors. Luna: That's a huge quality of life improvement for users. But I imagine it also simplifies the engineering org. If you don't have to build conflict resolution logic, you don't need a dedicated infrastructure team. Lucas: They don't have a dedicated infrastructure team. Or an SRE team. Their uptime target is 99.95 percent, and they hit it with basically a few scripts and a fairly simple deployment on top of a cloud provider. Because the sync engine is stateless — the server is mostly just a relay for CRDT events — scaling is straightforward. They don't need to maintain complex stateful services. Luna: So the architecture itself reduces operational complexity. That's the kind of leverage a small team needs. Lucas: It's a deliberate philosophy. The CTO, Tuomas Artman, has said in interviews that every line of infrastructure code is a line not spent on product features. So they try to push complexity into the client where possible, and keep the server as dumb as possible. The sqlite crdt approach is the prime example. Luna: Does that mean they're not using a traditional database on the backend at all? Lucas: They do use PostgreSQL for the server-side persistence — but it's essentially a log of CRDT operations, not a source of truth for current state. The current state is computed locally from the CRDT log. That means the server database is append-only, which is much easier to scale and backup. No complex migrations, no locking issues. Luna: So the database is more of an event store than a transactional store. That's a pattern we're seeing more of, but usually with custom event sourcing frameworks. Linear built it themselves. Lucas: They did. And they open-sourced part of it — a library called 'Linear Sync' or something similar. But the key insight is that they didn't start by trying to build a generic sync platform. They built just what they needed for a project management tool. That constraint kept the scope manageable. Luna: How does the dogfooding play into the architecture decisions? I imagine when your own team uses the product daily, you feel the pain of poor performance immediately. Lucas: Absolutely. Artman has said that every engineer at Linear uses Linear to track their own work. So if the sync is slow, if there's a merge conflict, if the UI janks — they feel it themselves. That creates a tight feedback loop. It's not an abstract user complaint in a ticket queue. It's your teammate saying 'hey, the board lagged when I dragged this issue.' So the incentive to fix performance is direct and immediate. Luna: That's a strong argument for dogfooding beyond just marketing. It aligns engineering incentives with user experience. Lucas: And it scales to seven people because they all own the whole product. There's no division like 'frontend team' and 'backend team' — everyone touches everything. That only works if the codebase is coherent, which the single TypeScript monolith enables. Luna: But what happens when they grow? If they hire more engineers, does the architecture scale with the team? Lucas: That's the open question. They've said they plan to stay small — maybe 20 to 30 engineers tops. But at that size, a monolith can start to feel tight. However, because the sync layer is so cleanly separated, they could potentially split the codebase by domain — like issues versus projects versus teams — while keeping the same sync engine. That's a modular monolith, which is a well-understood pattern. Luna: So the architectural decisions that work for seven also set them up for a graceful path to moderate scale. Not every startup can say that. Lucas: No. Most startups over-architect early, assuming they'll need microservices and Kubernetes from day one. Linear did the opposite: they under-architected in the traditional sense, but over-invested in the one thing that mattered — the sync layer. Everything else is as simple as possible. Luna: And that simplicity is what lets them ship fast. I've seen their changelog — they ship multiple times a week. For a seven-person team, that's impressive. Lucas: They deploy to production many times per day. Continuous deployment, full test suite, no release managers. Because the codebase is uniform, the test suite runs across the whole stack. They use feature flags for risky changes, but generally, they trust the architecture. Luna: What's the one thing you'd take away from Linear's approach if you're building a product today, especially with a small team? Lucas: I'd say: choose one language, one database paradigm, and one sync strategy. Don't try to be clever with a dozen services. The constraint of a small team forces you to make hard trade-offs — Linear shows that the right trade-offs can produce a product that feels more polished than what teams ten times their size ship. Luna: So it's not about being small — it's about being focused. Lucas: Exactly. And eating your own dog food doesn't hurt either.