How to Write a Resume for Linear
Linear redefined project management with opinionated, beautifully crafted software, built by a small (~100-person), remote-first, quality-obsessed team. Its speed comes from a custom local-first sync engine that deliberately uses last-write-wins rather than CRDTs, and its culture is captured in CEO Karri Saarinen's line that 'quality is a choice we can make every day.' Public comp data is genuinely thin for a company this small (and easy to confuse with the unrelated 'Linear Technology' semiconductor firm), so this guide is honest about what's known — Levels.fyi's small sample plus founder-friendly equity and remote pay — and focuses on the craft bar that actually gets you hired.
Build Your Linear ResumeLinear Resume Example
John Doe
Summary
Senior Product Engineer with 7+ years building opinionated developer tools where product quality and velocity are inseparable. End-to-end ownership of features across TypeScript and React frontends, real-time sync engines, and system design choices that trade scope for craft. Known for performance optimization, taste in user experience, and an autonomous style that suits fast-moving teams where the details carry the magic.
Experience
- Owned an opinionated issue-triage workflow end-to-end in 4 weeks — from user research with 9 teams to pixel-perfect TypeScript/React UI — cutting average triage time from 32 min to 7 min per cycle
- Rewrote the list virtualization engine, reducing re-renders by 82% and holding 60fps scrolling across lists of 12,000 issues on low-end laptops — a performance optimization adopted company-wide
- Shipped a real-time sync layer using CRDTs that achieved sub-9ms local write latency and conflict-free convergence across 99.9% of concurrent sessions for 18K daily collaborative editors
- Cut 38% of planned roadmap scope through an impact analysis workshop, preserving 91% of projected value and shipping the focused release 6 weeks early with product quality NPS of 74
- Led end-to-end ownership of a keyboard-first command palette in TypeScript and React, reaching 68% weekly adoption among 24K active users and reducing top-task time-to-action by 47%
- Designed a local-first architecture with IndexedDB and a custom sync protocol that delivered seamless offline editing and a p95 keystroke latency of 14ms across web and Electron clients
- Rewrote the animation system used across 40 UI surfaces, cutting dropped frames on scroll and modal transitions by 71% and raising the user experience polish bar for the whole product
- Operated autonomous as the sole engineer on a developer tools API redesign, shipping a breaking v2 with a migration guide that 92% of 180 integration partners adopted within 60 days
- Built a React and TypeScript project tracker for engineering teams, taking the product from 0 to 11K paid seats in 18 months through 9 iterative end-to-end shipped features
- Drove a system design overhaul of the sync backend, reducing real-time sync propagation p99 from 480ms to 70ms and sustaining a 5x traffic increase without downtime over 12 months
- Owned performance optimization across the web app, cutting time-to-interactive from 2.9s to 0.9s on mid-tier Android devices by rewriting the initial render path and data loader
- Mentored 3 engineers into full product quality ownership on their first end-to-end features, each shipping within their first quarter with zero post-release P0 incidents
Projects
- Built an open-source micro-animation library focused on product quality and craft, earning 3.9K GitHub stars and 5.2K weekly npm downloads across 260+ dependent developer tools
- Shipped 9 curated primitives — not 90 — as a 'Less but Better' design choice, with a consistent 60fps budget across all interactions and bundle size under 6KB gzipped
- Authored a playground for experimenting with real-time sync strategies, used by 700+ engineers in interviews and study groups, with visualizations of CRDT convergence across 12 scenarios
- Paired the project with a 3-part essay on system design trade-offs that drew 22K reads and 4 conference-talk invitations from fast-moving teams in the developer tools space
Education
Certifications
Technical Skills
What Should You Know About Linear Before Applying?
Headquarters
San Francisco, CA (Remote-first; US & Europe)
Industry
Project Management, Developer Tools, SaaS
Hiring Bar
Extremely selective, reflecting the small team and quality-first culture. Engineering candidates face deep technical interviews on system design, performance, and code quality — expect discussions of rendering performance, local-first data sync, and offline architecture, and expect them to reward candidates who understand Linear's actual sync engine (last-write-wins, not CRDTs). Design and product roles run portfolio deep-dives that assess taste and opinionated thinking. Across roles, Linear evaluates whether you can operate autonomously, hold an exceptionally high quality bar, and make disciplined decisions about what NOT to build. Posted engineering roles are mostly framed as 'Senior / Staff.'
Culture & Values
Linear's culture is defined by an obsessive commitment to quality and a belief that less is more. The team is intentionally small and remote-first (open to the US and Europe), and every person is expected to have outsized impact with high autonomy and high accountability, owning features from conception to polish. The company prefers opinionated design decisions over flexible-but-mediocre compromises, and treats speed of execution as a core advantage. The Linear Method (its published set of product principles — scope projects down, generate momentum rather than sprint, write issues not user stories, build with users) guides how the team works, and the craft bar extends from code quality to UI animation to customer communications.
What Is It Like to Work at Linear?
Beyond the interview loop, here's what the day-to-day looks like — and how compensation and scope grow from entry to staff-plus levels.
A Day in the Life
Engineering at Linear is small-team, remote-first, and craft-first. The team is around 100 people, distributed across the US and Europe, and every engineer owns features end-to-end with minimal oversight. The product's signature speed comes from a custom local-first sync engine built by co-founder/CTO Tuomas Artman (who built sync engines for a decade at Uber and Groupon): the client downloads a project's data into IndexedDB, keeps an in-memory layer of MobX observables, and pushes changes to the server through an event-driven system with last-write-wins conflict resolution. Conflicts are rare in an issue tracker, so Linear stayed with LWW and only recently adopted CRDTs — and only for issue descriptions. The work is opinionated by design. The Linear Method guides how the team operates — scope projects down, generate momentum rather than sprint, write issues not user stories, build with users, and launch continuously. Quality is treated as a daily choice: polish, animation, and keyboard-first speed are non-negotiable, and the craft bar runs from code through UI to customer communication. Linear ships fast without trading away that bar, which is why disciplined prioritization — deciding what NOT to build — is as valued as raw output.
Career Progression
How scope, expectations, and deliverables shift across seniority levels.
Rare at Linear — it hires few juniors and expects high autonomy from day one. Comp sits below the reported median; the honest read is that Linear optimizes for senior generalists.
Owns features end-to-end with minimal oversight. Levels.fyi small-sample median SWE TC is ~$205K (indicative, not a robust band).
The common posted level ('Senior / Staff Product or Fullstack Engineer'); owns product areas and quality. Levels.fyi reports up to ~$386K for the top of its small sample, plus founder-friendly equity and remote comp.
Staff engineers set technical direction across the small team and raise the craft bar org-wide. Linear does not publish a public ladder beyond 'Senior / Staff,' so treat any single comp figure with caution.
What Does Linear Look For in a Resume?
Understanding Linear's hiring priorities helps you tailor your resume effectively. Focus on these key areas to align with what their recruiters and hiring managers value most.
Key Principles
Exceptional craft — polished, high-quality output from code to interaction detail
Ability to work autonomously and own features end-to-end on a small team
Disciplined prioritization — knowing what to cut matters as much as what to build (less but better)
Experience building fast, local-first, responsive applications (described accurately — LWW/offline, not just 'CRDT')
Opinionated thinking about software design and willingness to make strong product decisions
Pro tip: Linear's team is tiny and every hire matters enormously. Your resume should read like a curated portfolio — fewer bullets, each demonstrating exceptional quality and end-to-end ownership. Remove anything merely 'good.' If you write about local-first or real-time features, describe them the way Linear works (IndexedDB, optimistic updates, last-write-wins, offline sync) rather than defaulting to 'CRDT,' which Linear deliberately avoided except narrowly for text.
What ATS Keywords Should You Use for a Linear Resume?
Linear uses applicant tracking systems to filter candidates. Include these keywords naturally in your resume to pass automated screening and reach the interview stage.
Must Include
Nice to Have
Pro tip: Linear's recruiters scan for craft obsession and technical depth, not a tech list. Embed 'performance optimization,' 'local-first sync,' and 'TypeScript/React' inside detailed accomplishment bullets that show how you used them. If you've built responsive, fast-loading UIs, local-first or offline-capable architectures, or developer-facing tools, make those the centerpiece — and describe sync precisely (LWW/offline) rather than reaching for 'CRDT.'
Rolevanta's AI tailors your resume to match Linear's hiring criteria.
Try FreeHow Should You Write Bullet Points for a Linear Resume?
Tailor your bullet points to reflect Linear's values and priorities. Use specific metrics and outcomes that align with what the company looks for in candidates:
Weak
Improved the performance of the web application.
Strong
Rewrote the list-rendering engine with virtualization and memoization, cutting re-render cycles by 85% and holding a consistent 60fps while scrolling lists of 10,000+ items on low-end devices.
Linear's product is renowned for speed. This bullet shows the exact performance obsession Linear values — not just 'faster' but buttery-smooth interaction at scale and on constrained hardware. The specificity about technique and target device signals real craft.
Weak
Worked on offline support for the application.
Strong
Built a local-first data layer (IndexedDB cache + in-memory observables + optimistic updates) with last-write-wins sync, delivering full offline functionality and sub-10ms local writes that converged cleanly on reconnect for 99.8% of sessions.
This mirrors how Linear actually works — a local-first sync engine using last-write-wins, not CRDTs. Naming the real architecture (IndexedDB, optimistic updates, LWW) signals you studied Linear's engineering rather than reaching for a buzzword the team deliberately avoided except for rich text.
Weak
Built a new feature for the project-management tool.
Strong
Designed, built, and shipped an opinionated sprint-planning workflow end-to-end in 3 weeks — from user research with 8 teams to pixel-perfect UI — cutting average setup time from 40 minutes to 6.
This demonstrates autonomy with accountability: owning every phase from research to shipping, fast. The opinionated design choice (not serving every edge case) mirrors Linear's product philosophy, and the user-centric metric ties it to real impact.
Weak
Reduced the scope of the project to meet the deadline.
Strong
Led scope reduction on a 6-month roadmap initiative, cutting 40% of planned features through user-impact analysis while preserving 90% of projected value, and shipping the focused version 2 months early to strong adoption (NPS 72).
This embodies 'less but better.' Linear constantly decides what NOT to build. The bullet shows disciplined prioritization backed by analysis, not arbitrary cutting, and the NPS proves the focused version landed better.
What Insiders and Leaders Say About Linear
Published perspectives from Linear leaders, engineers, and hiring insiders — cited and linkable to their original sources.
“Quality is a choice we can make every day.”
Karri Saarinen
Co-founder and CEO of Linear
“Technology makes it faster to build, but harder to care.”
Karri Saarinen
Co-founder and CEO of Linear
“I don't want to build anything in the traditional sort of networking model anymore. I think sort of sync is such a better user or developer experience.”
Tuomas Artman
Co-founder and CTO of Linear
What Gets Candidates Rejected at Linear?
Recurring patterns that sink otherwise-strong applications — and how to frame your resume so you signal you've avoided them.
Cargo-culting "CRDT" for Linear
Linear deliberately uses last-write-wins (conflicts are rare in an issue tracker) and adopted CRDTs only recently, only for issue descriptions. Headlining 'CRDT expert' signals you haven't studied Linear's actual sync engine. Describe local-first work as IndexedDB, optimistic updates, offline sync, and LWW instead.
Volume over curation
Linear's less-but-better ethos means a dense, multi-page resume of average bullets contradicts the core value. A resume that can't prioritize signals an engineer who can't either. Curate ruthlessly and keep only genuinely excellent work.
Collaboration without ownership
Linear's tiny team means every hire owns features end-to-end. Bullets that all start with 'Collaborated with' or 'Contributed to' read as needing organizational scaffolding to deliver. Show where you independently owned something from concept to shipping.
Process over output
Agile-ceremony and methodology talk falls flat — the Linear Method even prefers 'issues' to 'user stories.' Linear cares what you shipped and how good it was. Replace process descriptions with concrete outcomes and quality indicators.
No craft or interaction-quality signal
Linear is known for polish, animation, and keyboard-first speed. Engineers who only show backend logic or feature checklists miss the bar. Highlight interaction quality, animation performance, or visual polish (Karri: 'Quality is a choice we can make every day').
What Resume Mistakes Should You Avoid When Applying to Linear?
Linear receives thousands of applications. These common mistakes can get your resume rejected before a recruiter ever reads it. Here's what to avoid and what to do instead.
1Headlining 'CRDT' when Linear deliberately uses last-write-wins
Linear's sync engine is local-first but uses last-write-wins conflict resolution because conflicts are rare in an issue tracker; it only adopted CRDTs recently, and only for issue descriptions (rich text). Making 'CRDT expert' your Linear hook signals you haven't studied the actual architecture. Describe local-first work accurately — IndexedDB, optimistic updates, offline sync, LWW — and you'll read as someone who did the homework.
2Including too many mediocre accomplishments instead of curating the best
Linear's 'less but better' principle applies directly to your resume. A dense, two-page resume of average bullets signals you can't prioritize — a critical skill on a small team. Edit aggressively; keep only accomplishments that demonstrate exceptional quality, and give each enough space to show depth.
3Describing collaboration without showing individual ownership
Linear's small team means every person owns significant pieces of the product end-to-end. If every bullet starts with 'Collaborated with...' or 'Contributed to...', it suggests you need organizational support to deliver. Show where you independently owned a feature from concept through shipping.
4Focusing on process and methodology over output quality
Agile-ceremony and methodology talk won't impress Linear — the Linear Method even prefers 'issues' to 'user stories.' They care about what you shipped and how good it was, not the process you followed. Replace process descriptions with concrete outcomes and quality indicators like animation performance and interaction polish.
Frequently Asked Questions
How much do engineers make at Linear, and why is the data thin?
Linear (linear.app) is a small, remote-first, well-funded startup, and public comp data is genuinely limited. Levels.fyi's linear.app page is a small sample — median software-engineer total compensation around $205K and a reported top near $386K — so treat it as indicative, not a robust band. Don't confuse it with 'Linear Technology,' an unrelated semiconductor company with lots of separate salary data. What's well-supported: Linear is remote-first (US and Europe), pays competitive salary plus equity, and offers founder-friendly equity terms (early exercise, extended exercise windows).
Does Linear use CRDTs for real-time sync?
Mostly no — worth knowing before you interview. Linear's custom local-first sync engine (built by CTO Tuomas Artman, who built sync engines at Uber and Groupon) downloads project data into IndexedDB, keeps an in-memory observable layer, and syncs via an event-driven system using last-write-wins. Conflicts are rare in an issue tracker, so LWW is sufficient; Linear only adopted CRDTs recently, and only for issue descriptions. Describe local-first work with that in mind rather than defaulting to 'CRDT.'
How small is Linear's team, and what does that mean for candidates?
Linear operates with a very small team (~100) relative to its product impact and customer base, and it hires mostly senior generalists. Every hire must be exceptionally strong and self-directed. Your resume should show you can operate autonomously, own features end-to-end, and hold a high quality bar without heavy management oversight.
What technical stack does Linear use?
Linear is TypeScript-heavy with React on the frontend, built around a custom local-first sync engine (IndexedDB cache, in-memory MobX observables, event-driven server sync, last-write-wins). Experience with TypeScript, React, performance optimization, offline-capable architectures, and local-first data is highly relevant. There's also a desktop app, so cross-platform experience is a plus.
How important is speed of execution at Linear?
Extremely important. Linear ships fast and expects candidates who can do the same without sacrificing quality — the Linear Method literally talks about generating momentum rather than sprinting. On your resume, include timelines where relevant, especially where you delivered high-quality work in compressed timeframes, to show you can maintain Linear's pace while upholding its craft bar.
Should my resume be one page for Linear?
Strongly recommended. Linear's 'less but better' philosophy is the perfect guide for resume length. A focused, one-page resume with 4-6 exceptional bullets aligns with Linear's values far better than a sprawling two-pager. Every line should be your best work — if a bullet doesn't make you proud, cut it. As Karri Saarinen puts it, quality is a choice you make every day.
Sources
- Linear Software Engineer Salary (small sample — indicative) — Levels.fyi
- Linear Careers (remote-first; equity terms) — Linear
- The Linear Method — Linear
- Why is quality so rare? (adapted from Config 2025 keynote) — Linear (Karri Saarinen)
- OEWS May 2024 — Software Developers (15-1252) — U.S. Bureau of Labor Statistics
- localfirst.fm #15: Tuomas Artman on Linear, sync engines, rethought startup MVP — localfirst.fm
- Inside Linear: Why craft and focus still win in product building — First Round Review (Karri Saarinen)
- Karri Saarinen's 10 Rules for Crafting Products That Stand Out — Figma Blog
- Linear Interview Guide: Offline-First Sync Engine — techinterview.org (confirmatory)
Similar Company Resume Guides
Resume Examples for Top Linear Roles
Explore role-specific resume guides for the positions Linear hires for most frequently.
Ready to Apply at Linear?
Stop spending hours customizing your resume. Let Rolevanta's AI create an ATS-optimized resume tailored to Linear's hiring standards in minutes.
Get Started Free