Project Risk Management: Frameworks, Tools & Practical Examples for Service Teams

If your fixed-fee project just slipped\ through a sprint, your SME is double-booked, and the client’s approval has been “with legal” for five days, you don’t have a creativity problem or risk management problem. 

💡 Service work lives at the intersection of scope, capacity, dependencies, and cash. When those signals stay scattered across tools (or buried in someone’s spreadsheet), risks mature into over-burn, date slips, and strained clients before anyone can act.

This guide gives IT services, consulting, and creative teams a practical way to operationalize risk without bureaucracy. 

We’ll start with the core mechanics (project risk analysis vs assessment), then apply a right-sized framework you can run in 10 minutes a week. You’ll get a one-page risk plan, a taxonomy that matches real delivery, early-warning signals that actually predict trouble, and domain-specific plays you can ship this week.

👉 Why now – and why here? 

Because the winning approach keeps signals → decisions → commercial impact on one surface. We’ll show how to do that end-to-end with Avaza, so risks, time, resourcing, approvals, and invoicing move together. By the end, you’ll have the checklists, views, and habits to stop surprises and the confidence to say, “Yes, we’ve got this,” when the next dependency wobbles.

What is Project Risk Management (For Service Teams)?

Project risk management is the process of identifying, analyzing, prioritizing, and treating uncertainties that could help or harm your project goals (scope, schedule, cost, quality, client satisfaction). 

For services organizations “where margin lives and dies on utilization, change control, and handoffs” risks concentrate around estimation, resourcing, dependencies, and client alignment. A right-sized approach focuses on visibility + cadence + ownership rather than heavyweight documentation.

The 5-Step, Right-Sized Risk Framework (with Avaza moves)

Use this as your weekly operating rhythm. It’s lightweight, repeatable, and visible to your team and clients.

1) Scope the stakes (set risk appetite up front)

Start by making your risk appetite explicit so there’s zero ambiguity later.

• Define non-negotiables: budget variance thresholds (e.g., ≤10%), schedule tolerance (e.g., ≤2 weeks), quality bars (acceptance criteria), and client KPIs.
• Capture assumptions (what must be true) and constraints (what can’t change).
• Lock down change-control rules (when a CR is required, who approves, SLA for decisions).

▶️ Avaza move: Put this in the Project Brief and pin a “Risk Overview” task at the top. Expose it through the client portal so stakeholders agree to the same guardrails from day one.

2) Collect risks where work actually happens

Risks shouldn’t live in a siloed spreadsheet. They should sit next to the tasks, time, files, and approvals they affect.

• Treat each risk as a first-class task (one risk = one task).
• Add structured fields: Category, Probability (P), Impact (I), Priority (P×I), Owner, Trigger, Treatment, Next Review.
• Use consistent taxonomy for categories (Scope, Resourcing, Estimation/Budget, Technical/Integration, Vendor/Dependency, Client/Stakeholder, Compliance/Operational).

▶️ Avaza move: Create a custom field set and Saved Views:

• Risk Register (List) for weekly decisioning.
• Heat Map (Board grouped by Priority) for fast triage and exec visibility.

3) Analyze simply (enough rigor, zero bloat)

You don’t need actuarial science—just a consistent scoring model and early-signal tracking.

• Score P (1–5) and I (1–5); compute Priority = P×I (range 1–25).
• Add Trend (Up / Stable / Down) to capture risk velocity.
• Focus depth on the vital few: the ~20% of risks that drive ~80% of exposure.

💡 Pro tip: When uncertainty (variance) is high, emphasize leading indicators (e.g., unplanned work %, task aging, approval latency) to catch acceleration before impact lands.

▶️ Avaza move: Build a dashboard widget that tracks count of High/Critical risks and a line chart of their trend over the last 4–8 weeks.

4) Assign owners & treatments (convert risk into action)

Clarity beats volume. Every material risk gets one accountable owner and a defined response.

• Choose a treatment strategy: Avoid, Reduce, Transfer, or Accept (with rationale).
• Define the Trigger (the observable condition that forces action) and the Due Date for the next decision.
• Make the path auditable: comments, attachments, and client-visible notes for transparency.

▶️ Avaza move: Add recurring subtasks such as:

• “Validate trigger conditions”
• “Update treatment & P/I if trend=Up”
• “Post weekly client summary if status=High/Critical”

5) Review on cadence (10 minutes, every week)

A short, consistent loop prevents surprises and keeps the backlog honest.

• Run a 10-minute risk stand-up inside your weekly status.
• Hit, in order: Critical → High → New. Close or de-escalate Low/Medium in bulk.
• Escalate when trend=Up or when triggers fire.

▶️ Avaza move:

• Schedule a recurring event at project creation.
• Use a Saved Report filtered to “Critical/High” to drive the conversation.
• Auto-share a one-line weekly summary via the client portal to reduce offline status churn.

Project Risk Analysis Vs Project Risk Assessment, What’s The Difference?

▶️ Project risk analysis is about understanding the risk:

• Root causes and causal chains
• Upstream/downstream dependencies
• P/I scoring and leading indicators (early warning signals)

▶️ Project risk assessment is about deciding what to do next:

• Rank by Priority (P×I) and risk appetite thresholds
• Select treatment (Avoid/Reduce/Transfer/Accept)
• Allocate owner, capacity, and timeline

Practical rule for services teams:

• Do analysis quickly, then move to assessment immediately—so owners, triggers, and treatments are set while context is fresh.
• Reassess weekly; if a risk’s trend=Up, revisit P/I and adjust treatment before it becomes an issue.

👉 Avaza tip: Sort your Risk Register by Priority, then filter by Category (Scope/Resourcing/Technical/Client/Compliance). This lets discipline leads make batch decisions in one tight review, instead of scattering decisions across multiple meetings.

Tools That Turn Project Risk Into an Operating System

Here are the top 5 options to operationalize risk. They’re alternatives, not a bundle—choose the one that maps to your dominant risk vector. (Avaza remains the recommended winner for most service teams.)

1) Avaza — The Control Surface (Winner)

When risk management actually changes outcomes, it has to live where planning, time/expenses, capacity, approvals, client visibility, and invoicing meet. 

Avaza is that single control surface where your team sees the same signals, makes decisions in one place, and every commercial impact is traceable and auditable from the first red flag to the approved change request and the invoice that reflects it.

👉 What it’s for (end-to-end loop):

Run everything in one flow: the risk register (one risk = one task), the delivery plan, Resource Scheduling to protect critical roles, Approvals for auditable sign-offs and change control, the Client Portal for transparent status, and Invoicing to close the loop. 

Each risk carries its history, evidence, and cost impact so nothing gets lost in spreadsheets or side channels.

How you run it (fast):

• Fields: Category, P, I, Priority (P×I), Trend, Owner, Trigger, Treatment, Next Review. These make risks comparable across projects and ready for reporting.
• Views: Risk Register (List) for a tight 10-minute weekly review; Heat Map (Board by Priority) for exec triage; Waiting on Client to surface decision latency instantly.
• Dashboards: Budget vs Burn, approval latency, % unplanned, defect reopens, roles >100% load. These are the early-warning dials your Ops/PM/Founder personas actually act on.

Automation & governance (lightweight but real):

• Auto-reminders when Triggers fire (variance ≥10%, approvals >3 business days, SME load >100%).
• Notify the Sponsor on any Critical risk or Trend = Up.
• Route CRs through Approvals; attach revised SOW/estimates on the risk task to keep a clean audit trail.
• Share read-only risk views in the Client Portal so stakeholders see posture without extra reporting.

💡 Example flow (what “connected” looks like): Scope request lands → risk flips High and Trend = Up → Budget vs Burn shows variance approaching 10% → PM raises a CR from the risk task → Approvals capture sign-off → plan re-baselines → next invoice reflects the change. One record, zero duplicate entry.

Quick start (90 minutes):

1. Add the fields above and save Risk Register (List), Heat Map (Board), Waiting on Client.
2. Build a dashboard with Budget vs Burn, High/Critical trend, approval latency, % unplanned, >100% load.
3. Schedule the weekly 10-minute review; turn on trigger-based reminders.
4. Enable client access; test a CR via Approvals end-to-end.

Best fit: Teams that want predictable delivery, clean change control, and client-ready visibility—without juggling extra docs.

Anti-pattern: If you only need a dev bug tracker or a pure ledger, Avaza’s breadth is more than you require; pick the narrower tool that matches that single need.

Try Avaza For Free

If you feel that Avaza might be the right project risk management software for your team, sign up to start using Avaza for free. If you need any help with your Avaza subscription or want to better understand our pricing, please contact chat support or email support@avaza.com.

2) Jira (or Linear) — Technical Risk & Test Gates

If your biggest exposure is engineering uncertainty “integrations, API limits, data quality, security” an issue tracker excels. It converts risks into testable tickets with pass/fail gates and throughput targets so you can de-risk releases before go-live.

What it’s for: Sprint hygiene, release gating, and proving performance.

How you run it: Model treatments as epics/issues (sandbox POC, contract tests), set gate criteria pre-promotion, watch reopen rate and throughput trends.

Best fit: IT rollouts and integration-heavy projects where technical proof is the critical path.

Anti-pattern: It’s light on commercials and client comms; don’t expect it to manage approvals, budgets, or change control.

👉 Click here for price

3) QuickBooks Online — Finance Risk & Billing Accuracy

When margin integrity is the primary risk, choose a finance ledger. It’s the system of record for invoices, expenses, and GL, where budget risk becomes real (category variance, delayed billing, write-offs).

What it’s for: Enforcing rate/SOW alignment, tracking pass-through costs, and keeping invoicing timely

How you run it: Reconcile timesheets/expenses to SOW; monitor category variance (e.g., >10%) and DSO/invoice timeliness; escalate when drift persists.

Best fit: Firms that deliver well but lose money at billing.

Anti-pattern: Not a delivery planner; avoid duplicating project decisions here.

👉 Click here for price

4) Salesforce — Deal-To-Delivery Handoff & Assumptions

If surprises keep starting in sales, pick a CRM to capture promises, SLAs, start dates, and dependencies before kickoff, so delivery inherits explicit guardrails.

What it’s for: Turning opportunity terms into project assumptions and “red lines.”

How you run it: Map fields (scope boundaries, data dependencies, security/compliance) and seed initial risks at day zero.

Best fit: Agencies/consultancies with complex SOWs or bespoke commitments.

Anti-pattern: A CRM won’t run execution; ensure captured assumptions actually drive project setup.

👉 Click here for price

5) Zendesk — Unplanned Work & Client Signals

If post-launch noise drives risk, a support desk is the clearest lens. Queues reveal scope cracks, quality debt, and stealth change requests fast.

What it’s for: Rolling tickets into themes, quantifying % unplanned weekly, and spotting VIP latency before relationships strain.

How you run it: Tag themes, set tripwires (e.g., % unplanned >15%), and route to backlog or change request when threshold trip.

Best fit: Retainers, productized services, ongoing success motions.

Anti-pattern: Raw tickets are noisy, always curated into quantified themes before acting.

👉 Click here for price

Practical (Domain-Specific) Examples You Can Run This Week

Turning signals into action is where risk management pays off. Below are common scenarios with the risk, treatment, trigger, and ownership you can copy.

▶️ Fixed-Fee Web Redesign: Mitigate Scope Creep

Scope drift hides in design feedback loops and vague acceptance criteria. Keep the perimeter tight and decisions auditable so fixed-fee margin doesn’t evaporate.

• Risk: Discovery gaps drive >15% rework and milestone slip.
• Treatment: Time-boxed discovery → explicit design acceptance criteria → enforce Change Request (CR) gate.
• Trigger: Any request outside signed scope or estimate variance >10%.
• Owner: Engagement Lead.

👉 Avaza move: Keep acceptance criteria on the task; run mockup sign-off with Approvals; route CRs via a Change Control workflow and attach updated SOW PDFs so scope, dates, and fees stay aligned.

▶️ IT Rollout: Reduce Integration Risk

Integration risk creeps in via API limits, messy data, and late security reviews. Treat throughput like a first-class KPI and prove the path early.

• Risk: API rate limits + data quality issues delay go-live.
• Treatment: Sandbox POC, schema validation, performance test plan with gates.
• Trigger: Failed test cases or throughput < target in pre-prod.
• Owner: Technical Lead.

👉 Avaza move: Track test suites as tasks; log Time → “Testing” to forecast overage; link Jira issues bi-directionally for plan → test → fix traceability.

▶️ Consulting Engagement: Protect Margin Via Capacity

Single-threaded SMEs and invisible PTO collisions derail timelines. Book capacity like inventory and keep coverage visible.

• Risk: Senior SME overbooked; milestones slip, context switching rises.
• Treatment: Cross-train backup; lock SME availability in Resource Scheduling; pre-agree decision windows with the client.
• Trigger: SME utilization >95% or overlapping PTO on the critical path.
• Owner: Delivery Manager.

👉 Avaza move: Use Resource Scheduling (Team vs Project view) to secure capacity; auto-alert PM when conflicts or >100% load appears; drag-and-drop rebalance.

What Does A Risk Management Plan Look Like In Project Management?

For service teams (IT, consulting, creative), the most effective plan is a one-page control surface: quick to read, rigorous enough to guide decisions, and easy to operationalize inside Avaza. Think clarity over ceremony – the goal is shared guardrails, fast triage, and an auditable trail from risk to treatment.

1) Objectives & thresholds — set risk appetite up front

Start with a short narrative that ties delivery to commercial reality, then anchor it with measurable limits.

• Budget: ≤10% variance on total hours/fees before a Change Request (CR) is mandatory.
• Schedule: ≤2 weeks cumulative slip on the critical path; re-baseline if exceeded.
• Quality: acceptance criteria per workstream; defect reopen rate capped (e.g., ≤5%).
• Client success: CSAT/NPS targets; approvals SLA (e.g., ≤3 business days).
• Red lines: conditions that force escalation (e.g., under-resourced critical role, vendor delay >7 days).

Avaza move: Capture this in the Project Brief and pin a “Risk Overview” task that’s visible in the client portal so everyone operates from the same guardrails.

2) Categories you’ll track — a shared taxonomy keeps analysis fast

Explain that categorization standardizes language across accounts and accelerates triage.

• Scope & Change (requirements, creep, sign-off drift)
• Resourcing & Capacity (critical skills, over-allocation, PTO collisions)
• Estimation & Budget (effort undercall, rate misalignment, pass-through costs)
• Technical & Integration (API limits, data quality, legacy constraints, security reviews)
• Vendor & Dependency (third-party timelines, asset delivery, platform approvals)
• Client & Stakeholder (decision latency, turnover, competing KPIs)
• Compliance & Operational (SOW gaps, audit obligations, billing accuracy)

Avaza move: Implement categories as Tags/Custom Fields so you can filter risks and produce cross-project trend reports without extra work.

3) Scoring model — rigor without bureaucracy

Frame the scoring model as a consistency tool, not paperwork. Keep it simple and repeatable.

• Probability (P): 1 (rare) → 5 (likely)
• Impact (I): 1 (minor) → 5 (red-line failure)
• Priority = P × I (1–25) with bands: 1–5 Low · 6–10 Medium · 11–15 High · 16–25 Critical
• Trend: Up / Stable / Down to capture velocity and prompt re-assessment

Practical cues: Mark P=4–5 when there’s a fresh signal (e.g., approval latency >3 days). Mark I=4–5 when impact touches budget, timeline baseline, or contractual obligations.

Avaza move: Model P, I, Priority, Trend as Custom Fields and create two Saved Views—Risk Register (List) for decisions and Heat Map (Board by Priority) for exec triage.

4) Cadence — a 10-minute weekly loop beats surprises

Set expectations that risk control is a rhythm, not a one-off document.

• Weekly risk stand-up (10 min): review Critical → High → New; reconfirm Owner + Next Action + Trigger.
• Monthly retrospective: identify recurring drivers; strengthen controls and templates.
• Trigger checks: scan leading indicators—unplanned work %, resource load >100%, blocked task aging, burndown vs. hours divergence.

Avaza move: Schedule the review as a recurring event; drive it with a Saved Report filtered to Critical/High and a Dashboard showing trendlines and approval wait times.

5) Roles — RACI that fits services

Clarify who’s accountable so action doesn’t stall.

• Project Manager (Accountable): owns the register, scoring discipline, and weekly cadence.
• Discipline Leads (Responsible): own treatments and trigger checks within their domain.
• Sponsor / Account Lead (Escalation): clears blockers; aligns commercial actions (CRs, re-baseline).
• Client Stakeholders (Consulted): timely approvals; explicit risk acceptance where relevant.
• Finance/Operations (Informed): margin, billing accuracy, and cash-flow implications.

Avaza move: Assign Owners on each risk task; @mention the Sponsor on Critical items; expose read-only views to clients via the client portal for transparency.

6) Communication — crisp rules + change control

Explain how information flows when thresholds are hit, so no one guesses in a crisis.

• Notification matrix: who gets notified for High vs Critical, and on what channel.
• Change Requests: definition of “material change,” required artifacts (scope delta, revised estimate, date impact), and approval SLA.
• Escalation path: PM → Sponsor → Executive, with time limits.
• Client transparency: weekly one-liner on risk posture; Critical items always visible.

Avaza move: Store the CR template as a task form; run approvals through Approvals; keep the audit trail in task comments/attachments and share outcomes in the portal.

Which risk categories matter most for IT, consulting, and creative teams?

Service projects fail where scope clarity, capacity, dependencies, and decision velocity intersect. 

Use the categories below as a shared taxonomy—so Ops, PMs, and Founders make comparable decisions across accounts and you can roll up clean portfolio reports.

1) Scope & Change

Scope is your commercial perimeter; when it drifts, margin follows. In practice this shows up as ambiguous requirements, ad-hoc requests, late sign-offs, or missing acceptance criteria that quietly inflate effort and force milestone resets. 

The remedy is a disciplined discovery phase, explicit acceptance criteria in the brief, and a formal Change Request (CR) gate that captures deltas to scope, dates, and fees. 

In Avaza, keep requirements and acceptance criteria on the task itself, tag scope-sensitive work with Scope, and route CRs through Approvals with the revised SOW attached—so every change is visible, auditable, and priced before work proceeds.

2) Resourcing & Capacity

Capacity shocks sink timelines faster than defects. Projects wobble when a critical skill is unavailable, a key contributor is over-allocated, or PTO collides with the critical path. 

Protect delivery by reserving capacity for high-risk roles, cross-training backups, and monitoring real utilization versus plan. 

Avaza’s Resource Scheduling (Team and Project views) lets you lock key people early, see load creeping above 100% before it lands on the schedule, and rebalance assignments with drag-and-drop clarity.

3) Estimation & Budget

Estimation is where gross margin lives or dies. Under-called effort, missed pass-through costs, or rate misalignment produce over-burn and strained client trust. 

The fix is range-based estimates with explicit assumptions, frequent burn checks, and timely CRs when variance crosses your threshold. 

Inside Avaza, Time Tracking and Expenses roll straight into a Budget vs. Burn dashboard; when variance crosses, say, ≥10%, you can raise a CR with supporting timesheets and comments, keeping conversations factual and fast.

4) Technical & Integration

Integration friction and legacy constraints are classic schedule killers. You’ll feel it as API rate limits, unstable sandboxes, messy data, or a late security review. 

Plan for this with a sandbox proof-of-concept, contract tests, performance gates, and early SecOps touchpoints. Track test plans and gates as tasks in Avaza, tag them Technical, and log time specifically to “Testing” so creeping effort is visible. 

If you manage defects elsewhere, link the external tracker from the task to preserve end-to-end traceability.

5) Vendor & Dependency

Your throughput is only as fast as the slowest partner. Late assets, platform approvals, or batched dependencies generate idle time and cascading replans. 

Insist on dated delivery commitments, build fallback paths, and carry explicit buffers where the risk is highest. 

In Avaza, tag these items Vendor/Dependency and maintain a “Waiting on External” view; it gives you a single place to chase, unblock, and re-prioritize before the delay hits the critical path.

6) Client & Stakeholder

Decision latency is invisible until everything stalls. Slow approvals, champion turnover, conflicting KPIs, or legal cycles create blocked tasks and scope ambiguity. 

Clarify RACI up front, set approval SLAs, and pre-agree patterns that avoid re-debating common decisions. 

Avaza’s client portal centralizes approvals and live status, while a “Waiting on Client” filter keeps your stand-up focused on the blockers that truly threaten dates and margin.

7) Quality & Rework

Late quality costs twice “once in rework and again in reputation”. Watch for a rising defect reopen rate, accumulating UX debt, or vague definitions of done. 

Strengthen your definition of done, layer reviews where risk is highest, and automate checks when possible. 

In Avaza, tag quality-sensitive work Quality, run design and content sign-off via Approvals, and surface reopen metrics on a dashboard so you can intervene before quality issues cascade into schedule risk.

8) Operational & Compliance

Operational and compliance issues aren’t glamorous, but they crater cash flow. SOW gaps, billing errors, audit obligations, or data-privacy requirements can turn solid delivery into write-offs or legal exposure. 

Use SOW checklists, reconcile billable records, and capture compliance artifacts as you go. 

Avaza’s connected flow—Tasks → Time → Invoicing—ensures what’s delivered matches what’s billed, while attaching contracts and evidence to tasks gives you an auditable trail when Finance or Legal needs it.

How Do You Score Risks Without Overthinking It?

Keep the model simple, consistent, and actionable. Your goal isn’t perfect precision; it’s comparable decisions week to week.

Core model (use everywhere):

• Probability (P): 1 (rare) → 5 (likely)
• Impact (I): 1 (minor inconvenience) → 5 (project failure / red-line breach)
• Priority = P × I: 1–25
• Color bands: 1–5 Low · 6–10 Medium · 11–15 High · 16–25 Critical
• Velocity (Trend): Down / Stable / Up to capture acceleration

Fast scoring rubric (so PMs don’t stall):

• Set P=4–5 if you see a fresh leading indicator (e.g., approvals >3 business days, load >100% on a critical role, blocked tasks aging).
• Set I=4–5 when the blast radius touches budget, baseline dates, or contractual obligations.
• If Trend=Up, recheck P and I immediately—even mid-week.

Make it operational (not theoretical):

• Create Custom Fields for P, I, Priority, Trend, and a Trigger (the condition that forces action, e.g., “unplanned work >15% this week”).
• Drive a 10-minute weekly risk review: work down Critical → High → New, set Owner + Next Action + Due, and close the trivial items quickly.

What Early Warning Signals Should You Watch?

💡 Implementation tip: In Avaza, model each signal with tags/custom fields (e.g., Blocked, Unplanned, Waiting on Client), drive a 10-minute weekly review off Saved Reports and Dashboard widgets, and set load/latency alerts so risks surface automatically—no extra spreadsheet required.

Frequently Asked Questions

What’s the difference between risk analysis and assessment?

Analysis explains causes, effects, and early signals; assessment ranks the risk and chooses a response (Avoid/Reduce/Transfer/Accept) with an owner and date. Do analysis fast → assess → revisit weekly. Avaza win: keep notes and decisions on the same risk task.

How do I prioritize when everything feels important?

Use Priority = P × I (1–25), work Critical/High first, then Medium; batch or close Low. Track Trend (Up/Stable/Down) so a Medium trending Up gets attention. Avaza win: sort the Risk Register by Priority and filter by Trend.

What software features matter most for service-team risk?

A single surface for tasks, time, resourcing, budgets, approvals, and client portal. Fragmented tools hide risks in handoffs. Avaza win: risks live beside Time Tracking, Resource Scheduling, Expenses, Invoicing, and Approvals, so signals and actions stay connected.

How do I keep clients aligned without slowing delivery?

Expose a client-facing risk view, run key sign-offs through Approvals, and post a one-line weekly risk summary (“posture stable / trending up; actions assigned”). Avaza win: share read-only Saved Views in the client portal for zero-friction visibility and auditability.

Final take: Turn Risk Into A Weekly Advantage

▶️ Projects rarely blow up overnight “they drift through tiny misses: a late approval, an overbooked SME, a test that almost passes”. 

Teams that win aren’t luckier; they’re quicker at seeing and acting. A right-sized risk practice gives you the language, the simple math, and the cadence to turn uncertainty into decisions.

Carry this forward: keep signals, decisions, and dollars on one surface. When your risk register sits beside time, capacity, approvals, and invoicing, you catch trouble early, price change fairly, and protect margin without drama. That edge matters most on fixed-fee work and multi-party integrations.

Your next steps, this week

• Ship the one-page risk plan and run a 10-minute weekly review.
• Use the shared taxonomy so risks read the same across projects.
• Track the early signals—variance, latency, overload, reopens – where the team already works.
• Automate change control so scope, dates, and fees stay aligned (and auditable).

This is where Avaza excels. 

With risks, time/expenses, resource scheduling, approvals, client access, and invoicing in one flow, your process stops being a document and becomes a habit. That habit restores predictability, earns trust, and lets you say “yes” to bigger, more complex work – confident that when risk appears, you’ll see it first and move fastest.