Skip to content

// Prioritization Frameworks

Decide what matters, then do it.

Capturing tasks is easy. Deciding which ones to do first is where teams stall. This guide compares four proven frameworks - Eisenhower, MoSCoW, RICE, and kanban WIP limits - and shows how to implement each one on a kanban board.

Why prioritization is the hardest part of task management

Every team has more tasks than time. Prioritization is the discipline of choosing which tasks to do and - just as importantly - which ones to skip. Without a framework, prioritization devolves into whoever argues loudest or whoever has the most authority. The result is a backlog that grows indefinitely, urgent requests that displace important work, and a team that feels busy but never makes meaningful progress.

The right prioritization framework gives your team a shared language for making tradeoffs. Instead of debating whether to fix the login bug or build the new dashboard, you have a process that produces a clear answer - or at least narrows the debate to a productive conversation. The framework does not make the decision for you, but it ensures the decision is made deliberately and consistently.

There is no single best framework. The right choice depends on your team size, how quickly priorities shift, and how much overhead you can tolerate. This guide covers four approaches that span the spectrum from lightweight to rigorous, plus ICE, a lighter cousin of RICE, with specific instructions for implementing each one using labels, columns, and board structure in Flux.

Eisenhower Matrix: urgent vs. important

The Eisenhower Matrix sorts tasks into four quadrants based on two dimensions: urgency and importance. Named after Dwight Eisenhower, who observed that urgent tasks are rarely important and important tasks are rarely urgent, the framework forces you to distinguish between the two.

The four quadrants

  • Quadrant 1: Urgent + Important. Do these immediately. Production outages, security vulnerabilities, missed deadlines with real consequences. These tasks demand attention right now and have significant impact if left unaddressed.
  • Quadrant 2: Important + Not Urgent. Schedule these. Architecture improvements, documentation, team training, technical debt reduction. These tasks drive long-term success but never feel pressing, which means they get perpetually deferred unless you deliberately protect time for them.
  • Quadrant 3: Urgent + Not Important. Delegate or batch these. Many meeting requests, routine approval workflows, non-critical notifications. These tasks create the illusion of productivity because they demand immediate response, but they do not move meaningful work forward.
  • Quadrant 4: Neither Urgent Nor Important. Eliminate these. Speculative features no one asked for, premature optimizations, vanity metrics dashboards. If a task is neither urgent nor important, it should not be on the board.

How to implement with labels

Create four labels on your Flux board - one for each quadrant. Color-code them: red for Q1, blue for Q2, yellow for Q3, gray for Q4. Apply a label to every card. Filter the board by label to see each quadrant in isolation. During weekly review, scan Q4 items and archive anything that has been sitting there for more than two weeks.

Strengths and limitations

The Eisenhower Matrix is excellent for individuals managing their own workload. It is simple to understand, requires no math, and forces a useful distinction between urgency and importance. The limitation for teams is that urgency is subjective. What one engineer calls urgent another calls routine, and the matrix provides no mechanism for resolving that disagreement. Teams tend to inflate urgency because it is easier to justify working on something if it is labeled urgent, which erodes the framework over time.

Eisenhower matrix vs kanban: what is the difference?

The Eisenhower matrix is a prioritization method: it sorts tasks by urgency and importance into four quadrants (do, schedule, delegate and delete). Kanban is a flow method: columns show each task's stage, and a WIP limit caps how much is in progress. Use the matrix to choose the work and kanban to finish it.

Eisenhower matrix Kanban
Question it answers Which tasks matter most? How does work move to done?
Sorts tasks by Urgency and importance Workflow stage
Structure Four quadrants Columns, such as To Do, In Progress, Done
Main rule Do Q1, schedule Q2, delegate Q3, delete Q4 Finish work before pulling more (WIP limit)
Works best for One person's triage A team's shared flow
Cadence Daily or weekly review Continuous

How to use both on a Flux board

Every Flux card has a priority field with four values, Urgent, High, Medium and Low, plus No priority. The priority shows as a colored badge on the card, the board filter can show one or more priorities, and the board's Table view sorts by Priority, most urgent first. A simple mapping:

  1. Give Urgent + Important (Q1) cards the Urgent priority, and pull them into In Progress first.
  2. Give Important, not urgent (Q2) cards High and drag them to the top of the backlog, so the Table view's Priority sort keeps them in sight.
  3. Assign Urgent, not important (Q3) cards to whoever handles them, or batch them, and set Medium or Low.
  4. Archive Neither (Q4) cards rather than keeping them on the board.

Priority is one scale, so it loses the two-axis view. If you want to see the quadrants themselves, add the four quadrant labels described above as well and filter by label. Flux has no WIP-limit setting, so the kanban half is a team rule: write the limit in the column name, for example "In Progress (4)", and check it at standup.

MoSCoW method: must, should, could, won't

MoSCoW categorizes tasks into four buckets: Must have, Should have, Could have, and Won't have. It was originally developed for timeboxed projects where the team needs to agree on what will and will not be delivered within a fixed window.

The four categories

  • Must have. Non-negotiable requirements. If these are not done, the release fails or the sprint is not shippable. Keep this list short - if everything is a Must, nothing is.
  • Should have. Important but not critical. These add significant value and should be included if capacity allows. If the team is running out of time, Should items are the first to slip.
  • Could have. Nice-to-have improvements. These are included only if time permits after Must and Should items are complete. Polish, minor UX improvements, and low-impact optimizations often land here.
  • Won't have (this time). Explicitly excluded from the current cycle. This is the most valuable category because it makes scope cuts visible and deliberate rather than accidental. Saying no to something is a decision, and recording that decision prevents it from being relitigated mid-sprint.

How to implement with labels and columns

Create four labels: Must, Should, Could, Won't. Apply them during your planning session. Move all Must and Should cards into the To Do column. Leave Could cards in Backlog. Move Won't cards to a dedicated Won't column (or archive them with a label so they are preserved for future consideration). During execution, the team focuses on Must items first, then Should, then Could if time remains.

Strengths and limitations

MoSCoW excels at forcing explicit tradeoff conversations. The Won't category is especially powerful - it forces the team to name the things they are choosing not to do, which prevents scope creep and manages stakeholder expectations. The limitation is that MoSCoW is a batch process. It works best when applied at the start of a sprint or release cycle, which makes it less useful for continuous-flow teams that pull work on demand rather than planning in batches.

RICE scoring: reach, impact, confidence, effort

RICE produces a numerical score for each task by combining four factors: Reach (how many users or systems are affected), Impact (how much the task improves the outcome for those users), Confidence (how sure you are about the estimates), and Effort (how much time the task requires). The formula is straightforward: (Reach x Impact x Confidence) / Effort.

Scoring each factor

  • Reach. Estimate how many users, customers, or internal systems will be affected by this task in a given time period. Use a concrete number: 500 users per week, 3 API consumers, 12 team members.
  • Impact. Rate the magnitude of the effect on a scale. A common scale is 3 (massive), 2 (high), 1 (medium), 0.5 (low), 0.25 (minimal). This is the most subjective factor and benefits from calibration sessions where the team aligns on what each level means.
  • Confidence. A percentage reflecting how certain you are about the Reach and Impact estimates. 100% means you have data. 80% means you have strong intuition. 50% means it is a guess. This factor penalizes speculative work and rewards tasks with clear evidence.
  • Effort. Estimate in person-months, the work one team member can do in a month, using whole numbers (or 0.5 for anything well under a month). A task that takes one engineer two months has an Effort of 2. A task that takes three engineers one month has an Effort of 3. Larger Effort values push the score down, which naturally favors smaller, higher-impact tasks.

How to implement on a kanban board

RICE is best applied during periodic backlog refinement (grooming), not on every card. Score the top 20 to 30 backlog items quarterly. Record the RICE score in the card description, then drag the Backlog cards into score order (highest first) so the team always pulls the highest-value work next. Re-score when estimates change significantly - a task with new data might jump from a low to a high score.

Strengths and limitations

RICE produces a defensible ranking with clear justification for each position. It is especially valuable for product teams choosing between competing feature requests, because the score makes the reasoning transparent to stakeholders. The limitation is overhead - scoring every task is expensive, and the confidence factor is often unreliable for novel work. RICE works best at the initiative or epic level, not for individual bug fixes or chores.

ICE vs RICE: which should you use?

Use ICE when you need a fast ranking of many small ideas, such as growth experiments: rate Impact, Confidence and Ease from 1 to 10 and multiply. Use RICE when the choices are bigger and reach differs between them: it adds Reach and divides by Effort, so it takes longer but is easier to defend to stakeholders.

ICE stands for Impact, Confidence and Ease. Sean Ellis says he came up with ICE scoring when he needed a way for the growth teams he led to compare ideas across several dimensions (The Breakout Growth Podcast, March 2022). The common version rates each factor from 1 to 10 and multiplies the three (Itamar Gilad's ICE guide). Some teams average them instead, so write down which formula your team uses.

ICE RICE
Factors Impact, Confidence, Ease Reach, Impact, Confidence, Effort
Formula Impact x Confidence x Ease (Reach x Impact x Confidence) / Effort
Scales 1 to 10 for each factor Reach as a count, Impact 0.25 to 3, Confidence as a percentage, Effort in person-months (Intercom's original unit)
Effort to score Low: three quick ratings Higher: Reach and Effort need real estimates
Best for Growth experiments, quick idea triage Product initiatives competing for a quarter
Weak spot Gut-feel scores; Ease can favor small, easy ideas Reach is hard to estimate for new ideas

How to run ICE on a Flux board

Flux has no custom score fields and no sort by score, so ICE works the same way as RICE on a Flux board. Write the three ratings and the total in the card description, for example "ICE: 8 x 6 x 7 = 336", then drag the Backlog cards into score order, highest first. When an experiment's result changes how confident you are about similar ideas, re-score those cards and reorder.

Kanban WIP limits: structural prioritization

WIP (work-in-progress) limits take a fundamentally different approach to prioritization. Instead of scoring or categorizing tasks, WIP limits constrain how many tasks can be in any given column at once. When a column is full, no new work enters it until something moves forward. The effect is that the team must finish current work before starting new work, and the most important tasks naturally surface as the ones worth displacing current work for.

Why WIP limits work

WIP limits are structural rather than procedural. They do not rely on anyone remembering to score tasks, hold a planning meeting, or apply a label. The constraint lives on the board, where everyone can see it. When the In Progress column has a limit of four and all four slots are full, the only way to start something new is to finish something first. This creates a pull-based system where work flows at the pace the team can sustain, not the pace at which new requests arrive.

The most important secondary effect of WIP limits is that they make bottlenecks visible. If Review is always full and To Do is always empty, the team needs to spend more time reviewing and less time starting new work. Without WIP limits, this bottleneck is invisible - cards silently pile up in Review while everyone focuses on their own In Progress work.

How to set WIP limits

Start with a WIP limit equal to the number of team members for In Progress, and half that number for Review. Run with those numbers for two weeks and observe the flow. If cards are moving smoothly and no one is idle, the limits are correct. If cards pile up in a column, the limit might be too high (allowing too much parallel work) or the team might need to address a process bottleneck at that stage.

For a deeper look at how kanban boards and WIP limits work in practice, see the dedicated guide.

Framework comparison: which one should you use?

Framework Best For Overhead Team Size Cadence
Eisenhower Matrix Individual prioritization Low 1 person Daily
MoSCoW Sprint/release planning Medium 5-15 people Per sprint
RICE Scoring Product backlog ranking High Any Quarterly
ICE Scoring Growth experiments, quick idea triage Low to medium Any Per experiment batch
Kanban WIP Limits Continuous flow teams Low 2-10 people Always on

Practical recommendation

Start with WIP limits. They require the least setup, produce results immediately, and work without any ongoing scoring or categorization effort. Layer on RICE scoring when your backlog grows large enough that choosing the next initiative is genuinely difficult. Use MoSCoW when you need to scope a time-boxed delivery and need an explicit conversation about what is in and out. Reserve Eisenhower for personal task management outside the team board.

Flux has no WIP-limit setting, so a WIP limit on a Flux board is a team rule: put the number in the column name (for example "In Progress (4)") and check it at standup. Labels handle the MoSCoW and Eisenhower categorizations. RICE and ICE scores live in card descriptions. All four frameworks can coexist on the same board without conflicting with each other. Use an OKR tracker template to connect prioritized tasks to team-level objectives.

For more on the broader task management landscape and how prioritization fits into team workflows, see the pillar guide.

// FAQ
03 questions
01

Which prioritization framework is best for software teams?

+

For most software teams, kanban WIP limits are the best starting point. They require no scoring meetings, no spreadsheets, and no subjective debates about urgency. Agree a limit per column (in Flux, write it in the column name, for example "In Progress (4)"), pull work based on team capacity, and adjust the numbers as you learn your throughput. If your backlog grows large enough that choosing what to work on next becomes a real problem, layer RICE scoring on top for quarterly planning. MoSCoW works well for sprint-based teams that need explicit tradeoff conversations during planning sessions.

02

How do you implement the Eisenhower Matrix on a kanban board?

+

Create four labels: Urgent + Important, Important + Not Urgent, Urgent + Not Important, and Neither. Apply one label to each card. Filter the board by label to see each quadrant. The main limitation is that urgency is subjective - what one person calls urgent another calls routine. For teams, WIP limits and one explicit priority scale tend to be more actionable than the Eisenhower quadrants because they remove the urgency debate. In Flux, that scale is the card priority field: Urgent, High, Medium or Low.

03

Can you combine multiple prioritization frameworks?

+

Yes, and many teams do. A common combination is RICE scoring for quarterly backlog grooming (deciding which initiatives to commit to) plus WIP limits for daily flow control (deciding what to work on right now). Another pattern is MoSCoW for sprint planning combined with kanban WIP for execution within the sprint. The key is to use heavier frameworks less frequently - RICE once a quarter, MoSCoW once per sprint - and let the lightweight structural mechanisms handle day-to-day prioritization.

// Start prioritizing

Focus on what matters. Ship what counts.

Kanban boards with labels, priorities, and real-time sync. Free to start.