Software Engineer at Linear (2026)

Where Linear SWEs work — surfaces and the small team

From linear.app/careers (verified 2026-04-27):

• Core product (issue tracking, projects, cycles, roadmaps). The historical and dominant surface. React + TypeScript frontend; the local-first sync engine is the technical centerpiece.
• Linear API + integrations. The GraphQL API at developers.linear.app, OAuth, webhooks, integration partners (GitHub, Slack, Figma, Discord). Smaller team; broad ownership.
• AI features (Linear Asks, AI in projects). Newer surface as of 2025-2026; AI-augmented workflows for triage, summarization, project planning. Rapidly evolving.
• Mobile (iOS + Android). Native apps for both platforms. Smaller mobile team; high craft expectations.
• Infrastructure. Postgres clusters, Redis, the sync engine's backend, deploy systems. Documented in linear.app/blog/scaling-the-linear-sync-engine.
• Design system + design-engineering. Linear's UI is a substantial design-engineering investment; the team is small and integrated tightly with product engineering.

The defining structural feature: Linear's engineering team is small relative to its product impact. Under 100 engineers as of 2025-2026 building a product used by tens of thousands of teams. Individual scope is broad; engineers own product surfaces end-to-end rather than working in narrow specialist roles.

The take-home interview: what makes Linear's process unusual

Linear's hiring process explicitly centers a take-home project per linear.app/careers/process. The shape:

1. Recruiter screen (30 min). Background, role-fit, motivation. Linear values craft + opinion-on-quality; bring evidence of both.
2. Initial conversation with hiring manager (45-60 min). Discussion of past work; cultural alignment.
3. Take-home project (4-8 hours of work over 5-7 days). A real-shaped engineering task that resembles work Linear engineers actually do. For frontend roles: build a small interaction with state, sync, and craft considerations. For backend: design and partially implement a service. For full-stack: end-to-end small feature. The brief is detailed; the evaluation criteria are explicit.
4. On-site (3-4 rounds, ~3 hours):

• Take-home review. The signature round. You walk through your project; the interviewers probe decisions, ask 'why this and not that', and explore the trade-offs you made. This is the highest-signal round — Linear's evaluation is largely 'how does this engineer think when given real constraints'.
• System design / technical depth. Discuss a system design problem, often related to Linear's actual challenges (sync engines, real-time collaboration, offline-first architectures).
• Cross-functional partner round. Discussion of working with design, PM, founders. Linear's small team means cross-functional skill is load-bearing.
• Founders/leadership conversation (often Karri or another co-founder). Mission alignment, long-term motivation, role-fit at the senior level.

Why the take-home matters more at Linear than at peer companies: the on-site loop is short (3-4 rounds), and the take-home is what produces the deepest signal. Engineers who underinvest in the take-home (treat it as a checkbox) tend to fail; engineers who over-invest (200% perfectionist) also tend to fail because the time signal matters. Linear wants to see what you actually do in a constrained-time engineering context.

What good take-home looks like (from Linear's engineering blog and published guidance):

• Working code that does what was asked.
• Clear reasoning about what you cut for time.
• Tests on the high-value paths.
• Documentation that's appropriate for the complexity (a 4-hour project doesn't need a 50-page doc).
• Honest acknowledgment of what's incomplete.

Linear's stack and the sync engine

Linear's technical centerpiece is its local-first sync engine, documented at length in linear.app/blog/scaling-the-linear-sync-engine. Key elements:

• Local-first architecture: the client maintains a complete local copy of the user's data; mutations apply locally first, then sync to the server. Conflicts resolve via the sync engine using operational-transformation-like patterns plus per-entity reconciliation.
• Bidirectional WebSocket sync: persistent connection from client to server pushes mutations both directions in real time.
• Postgres + custom indexing layers: server storage is Postgres with custom indexing for the access patterns Linear's queries require.
• TypeScript end-to-end: the same type system spans frontend, backend, sync engine, and the mobile clients (via React Native or native Swift/Kotlin bridges).

The local-first model is what gives Linear its perceived speed — keystroke-level responsiveness without round-trips to the server for most operations. The trade-off: complexity in the sync engine, which Linear has invested heavily in solving.

Reference: in addition to the engineering blog post, Karri Saarinen's talks (e.g., 'Building Linear' at various conferences, indexed at linear.app/method) discuss the architecture choices.

Compensation, sourced

Linear publishes salary ranges per US pay-transparency laws on individual postings at linear.app/careers. From recent postings:

• Software Engineer (mid-senior): $200k-$280k base + equity, total comp $280k-$420k typical per recent postings.
• Senior Software Engineer: $250k-$340k base + equity, total comp $360k-$520k typical.
• Staff+: negotiable, typically aligned with senior tech-company staff levels.

Linear is private; equity is in the form of stock options. Last reported funding round (2024) at ~$1.25B valuation. Liquidity is via eventual IPO or acquisition; tender offers occur occasionally but are not regular.

Linear's pay strategy: Linear pays competitively for senior+ engineers but does not match peak FAANG total comp at any level. The trade-off Linear offers is: smaller team, broader scope, more direct impact, fully remote with strong async culture. Engineers optimizing for total cash compensation tend to choose FAANG; engineers optimizing for craft + scope + autonomy tend to choose Linear.