How We Use Linear for Project Management at Morgen
Spoiler: It’s not a strict rulebook.
What Is Linear (and Why We Use It)
Let’s talk Linear.
For the engineers it’s the easiest and fastest way to track tasks and manage sprints. We can prioritize, assign, and track progress without unorganized tasks or any other project management clutter. Previously we used GitHub Issues, but needed a place to centralize all the issues in a repository.
As our team expanded, we needed a project management tool that could help us monitor everyone's workloads and stay coordinated. Linear came highly recommended, but our initial experience was frustrating. We couldn't import our existing GitHub issues.This wasn't a technical limitation, though. Linear deliberately makes starting fresh part of their philosophy, encouraging teams to leave behind accumulated project debt and begin with a clean slate.
That’s what we did a few months later, on our second try. And since then our dev team always uses Linear. It’s fast, polished, with clean UI, and integrates with the tools we use (GitHub, Intercom, Slack).
How do we approach Linear?
We use a step-by-step approach where each phase leads into the next:
Plan → Build → Deliver
When developing a new feature, we begin with a clear goal (plan), break it into tasks (build), and push to production with internal QA and release tracking (deliver).
It’s not for everyone. But if your team thrives on structure, it’s worth exploring.
We also take it a step further by connecting Linear with Morgen. This allows us to import and schedule issues assigned to each of us directly in our individual calendars, and be aware of who is working on what, when, while being aware of our capacity on individual level.
Not Rigid—Just Clear
Linear helps us keep cycles focused, progress visible, and responsibilities clear without micromanaging. While we follow its workflow as our default approach, we're not afraid to loop back, adjust scope, or fast-track ideas when the situation calls for it. The real value is that it gives everyone from engineering to product a shared mental model for who works on what.
Our Workflow in 6 Stages
Here’s how we typically break down our projects:
1. Discovery & Planning
Big-picture thinking and architectural debates happen in Confluence
Early-stage discussions, including strategic direction, product requirements, and technical architecture, are captured in Confluence to keep conversations high-level and collaborative.
Figma is where designs start to take shape
Once ideas have a clear direction, we begin to explore visual concepts and user flows in Figma, translating concepts into interfaces.
Nothing enters Linear until we’re ready to define actionable tasks
We use Linear strictly for execution, only after ideas are approved we create issues. Since we don’t use backlog, we keep only issues we’re working on in our flow.
2. Design & Scoping
Split big ideas into manageable issues
Large features or initiatives are broken down into smaller, clearly defined tasks to ensure progress is trackable and teams can work in parallel.
Linked Figma files and Confluence pages provide context
Every issue includes direct links to relevant designs and documentation, so our team has quick access to the full background of each task.
3. Execution
Tasks move through a clean state flow
To Do → In Progress → In Review → Merged → Done
Our Linear workflow is intentionally simple and transparent, helping the team stay aligned on what's actively being worked on and what’s completed.
To do contains issues we’re tackling in the current cycle.
In progress is all about current sprint tasks that have started.
In review are issues that are done and need to be reviewed.
Merged issues are tasks which are done but not pushed live.
Done are issues which are finished and shipped live.
GitHub integrations update statuses automatically
We connect Linear to GitHub so that development progress reflects in real time. No manual updates needed, just automatic coordination between code and tasks.
Two-week cycles
We plan and execute in focused, two-week sprints, which helps us ship consistently, stay realistic about bandwidth, and keep the momentum high.
4. Review & QA
Reviews happen in GitHub but are reflected in Linear
Code reviews are conducted directly in GitHub, while Linear tracks the status so the whole team has visibility into what’s under review and what’s ready to merge.
QA is mostly informal and tied to the PR process
We rely on peer reviews and manual testing within the pull request flow, keeping quality checks lightweight but effective before code is merged.
5. Delivery & Wrap-up
We only mark tasks "Done" after they’re merged and released
An issue isn’t truly complete until it reaches production.
Before pushing issues live, we move them into “Merged” which signalizes the technical part is finished. We wait until changes are shipped in production before marking them as “Done” in Linear.
At sprint end, we review what shipped and what slipped
Every cycle closes with a quick retrospective to reflect on what we delivered, understand what got delayed, and adjust plans or priorities if needed.
6. Scheduling & Time Blocking with Morgen
Tasks planned in Linear are dragged into specific time blocks in Morgen
Once tasks are scoped, we schedule them in our calendars using Morgen. Morgen pulls in your issues for easy planning and time blocking. Some team members prefer to drag and drop, I use the AI Planner which schedules issues based on my prioritizations, in case any issue slipped or needs more time.
Here’s how we implement it:
- Connect your Linear account to Morgen.
- View Linear tasks directly inside Morgen’s calendar interface.
- Drag and drop tasks into time slots to schedule focused work blocks (or use AI Planner to give you realistic plan suggestions).
- Use tags and colors to differentiate areas of focus.
- Adjust time estimates directly from Morgen, helping align planned effort with real availability.
By assigning time to tasks, we avoid overcommitment and ensure the most important work gets the space it requires.
- Check off tasks directly from the calendar—no tab switching.
Progress becomes visible not just as a status update
You don’t just see movement in Linear, you push the work happening in real time on your schedule, creating a clear link between plans and execution.
Our setup
We tailor tools to each phase of our setup, here’s the summary:
What We’ve Learned
Over time, we’ve found a few tricks that work well.
Estimate task size with points
This gives us a solid sense of capacity. We can look at a sprint and know whether it's realistic. our team uses the exponential Linear scale for points.
Simple tasks:
1 point ~= 1 hour (notice, not 1 day)
2 points ~= 2 hours
Medium size tasks:
4 points ~= half a day
8 points ~= 1/1.5 day
16 points ~= 2-3 days
New features or major refactoring:
32 points ~= a week
64 points ~= a sprint (most likely this ticket is meant to be split in sub tickets by the owner of the project)
These estimates include the review, possible iterations on the code, and QA.
Avoid using Backlogs as a storage
One of the most important lessons is that backlogs are staging grounds. Early on, we used to dump lots of ideas into the backlog, only to forget or ignore them. Now, we actively prune it, and we even have automation to remove stale items after 6 months, moving them into a “Cancelled” status. If a task isn’t going to be tackled soon, we let it go.
The backlog way is based on what you thought then. The non-backlog way is based on what you think now. I'll take now.
Set priorities
Scope creep is real, especially with support-driven work. We accept that some sprint cycles will expand, but we track this closely and sometimes defer lower-priority work to maintain quality.
Thinking about trying Linear for Project Management?
If you’re thinking about adopting Linear project management, start by picking a clearly defined project, something with a known deliverable and deadline, like a feature launch or internal tool rollout.
Use the default state flow and aim to complete a full cycle, even if small. Don’t worry about enabling every feature, Linear works best when you grow into it. Avoid overstuffing your backlog. Just log what you’re ready to act on. Let teammates personalize how they interact with the system, and gradually introduce integrations like Slack, GitHub, or Morgen to amplify the experience.
It’s not about doing everything at once. It’s about finding a rhythm that makes your team’s work visible, intentional, and achievable.
Final thoughts
We use Linear for project management not to micromanage people, but to help us all see where we’re going and how we’ll get there. Whether you’re managing a team or working on solo projects, Linear can help you build with intention, keep you aligned with your team, and keep you focused.
Want to bring your tasks and team together like Marco? Integrate Morgen in your engineering workflow.
