Top 20 90-Day Goals That Drive Performance

Achieve a defect escape rate — bugs reaching production — of under 2% of all code shipped for 90 consecutive days.

A low escape rate means less firefighting, more shipping, and a product customers trust.

• Before submitting any PR, run through a personal quality checklist — edge cases, error handling, test coverage — as a non-negotiable final step.
• Review every bug you introduced in the previous week each Monday and identify one practice change that would have prevented it.

Deliver 90% or more of committed sprint work for 8 consecutive sprints without sacrificing quality.

Consistently delivering builds trust and makes your team's velocity genuinely predictable.

• At the start of each day, review your sprint commitments and identify the single most important task to complete today — do it first.
• Flag any commitment at risk of slipping at the halfway point of the sprint — not on the last day, when there is no time to adapt.

Respond to all code review requests within 4 working hours for 60 consecutive days.

Slow code review is one of the most invisible blockers in engineering — fixing it speeds up every team member's delivery.

• Block two 30-minute code review windows into your daily calendar — one in the morning, one after lunch — and treat them as fixed commitments.
• Before starting any new task, check whether a teammate has an open PR waiting for your review — unblock others before adding to the queue.

Complete one recognized technical certification or structured learning programme directly relevant to your role within 90 days.

The engineers who invest in learning compound their value — those who do not fall behind quietly.

• Spend 25 minutes each morning before standup on your certification or learning programme — protect this time before the day's demands arrive.
• Apply one concept from your learning to your actual work each week and document in one sentence how it changed your approach.

Locate, document, and resolve three meaningful performance issues within the next quarter, with measurable before-and-after metrics.

Every bottleneck fixed is a better product, a faster experience, and one fewer complaint to support.

• Spend 15 minutes each week profiling one area of the product for performance issues — not waiting for complaints, but looking proactively.
• Document every performance fix with before-and-after metrics and share it with the team — visibility creates momentum.

Produce clear, accurate technical documentation for every feature or change you ship for the next two sprints.

Code without documentation is knowledge locked in one person's head.

• Build documentation time into every ticket estimate — if a feature takes 4 hours to build, plan 45 minutes for documentation.
• Before marking any ticket done, confirm documentation is written, accurate, and linked — make it part of your personal definition of done.

Lower the average time from PR creation to merge by 30% within the next quarter.

Long-lived PRs create merge conflicts, slow the team, and signal unclear thinking.

• Before creating a PR, spend 10 minutes reviewing your own diff as if you were the reviewer — fix anything that would generate a comment.
• Write PR descriptions that answer three questions: what changed, why it changed, and how to test it — reviewers who understand context review faster.

Work with one junior engineer over 90 days until they can independently scope, build, and ship a feature without guidance.

One engineer raised to independence multiplies your team's capacity permanently.

• Spend 20 minutes each day with your mentee — reviewing their work, answering questions, or walking through a concept they are finding difficult.
• Give your mentee one increasingly complex task each week — stretch them deliberately rather than only assigning what you know they can handle.

Write and ship code that results in zero critical production incidents caused by your changes for three consecutive months.

A 90-day clean record is evidence of craft, care, and professional discipline.

• After every deployment, spend 15 minutes monitoring logs and dashboards for unexpected behavior — do not assume the absence of alerts means everything is fine.
• Before any deployment, run through a pre-flight checklist: rollback plan confirmed, feature flags set, monitoring in place, team aware.

Identify, propose, and successfully implement one improvement to the team's development process, tooling, or workflow within 90 days.

Engineers who make the team better create lasting value that individual output cannot match.

• Keep a daily log of any friction you encounter in the development process — in two weeks, the most repeated item is your best improvement opportunity.
• Bring one specific, well-reasoned process improvement proposal to the team each month — not a complaint, but a diagnosis with a solution.

Build the on-call processes, runbooks, and team capability to resolve 90% of production incidents within 30 minutes.

Fast recovery protects customers, preserves trust, and reduces the human cost of being on call.

• Review and update one runbook each week — a runbook not updated in 90 days is a runbook that will fail you in a real incident.
• Debrief every incident with the team within 24 hours — not to assign blame, but to identify the single improvement that would have cut recovery time in half.

Increase automated test coverage of core product functionality to 80% through a team-wide testing initiative.

Automated coverage gives the team confidence to ship faster without increasing risk.

• Add test coverage to every PR as a non-negotiable requirement — no PR merges without tests for the changed behavior.
• Review test coverage metrics as a team each sprint and assign the lowest-covered area to a specific engineer to address that week.

Identify, build, and release one significant feature within the next quarter that demonstrably improves a key customer outcome.

Engineering teams that connect their output to customer results build stronger relationships with the business.

• Start every sprint planning session with one question: which of these features will most directly improve a measurable customer outcome?
• Review customer metric movement after every major release as a team — connect the engineering output to the outcome it was meant to produce.

Dedicate structured time — at least 20% of engineering capacity — to technical debt reduction.

Teams that manage technical debt proactively move faster. Teams that ignore it eventually slow to a crawl.

• Protect a fixed percentage of every sprint for debt reduction — put it in the sprint before stakeholders fill the capacity with features.
• Maintain a visible technical debt register with the team — when debt is invisible, it never gets prioritized.

Build the CI/CD pipeline, testing infrastructure, and cultural practices that enable daily deployments.

Deploy frequency is the clearest proxy for engineering team health — higher frequency means lower risk per release.

• Review your deployment pipeline each week and identify the single biggest bottleneck preventing more frequent releases.
• Celebrate every successful deployment as a team, however small — frequency is a cultural habit, and habits are built through recognition.

Redesign the on-call process so the average engineer receives fewer than two pages per week.

Excessive on-call burden is a retention crisis waiting to happen.

• Review on-call alert volume every Monday and identify the single noisiest, least-actionable alert to fix or silence this week.
• Track on-call burden by engineer weekly — make it visible to the team so it is treated as a shared problem, not one person's suffering.

Develop a technical roadmap presentation so clear and outcome-oriented that it achieves full alignment in a single session.

Engineering leaders who communicate vision clearly earn the trust to execute it.

• Spend 20 minutes each week translating one technical priority into business language — what customer or company outcome does it enable?
• Test your roadmap narrative with one non-technical stakeholder each week before presenting it formally — their questions reveal your clarity gaps.

Identify two high-potential engineers, agree on a documented development plan with each, and deliver their first technical leadership stretch assignment — all within 90 days.

Technical leads are the scarcest resource in any engineering organization.

• Give each high-potential engineer one architecture or design decision to own each week — with your guidance, not your answers.
• Include each high-potential in one stakeholder conversation per week — technical leadership requires communication skills, not just technical ones.

Build a team culture where engineers feel challenged, trusted, and valued.

A high engagement score in engineering is both a retention strategy and a signal that the team is being led well.

• Have one informal, non-agenda conversation with each team member each week — not about the sprint, but about what they are finding energizing or draining.
• Recognize one specific technical contribution from a team member in writing each day — specific to the work, not generic appreciation.

Establish a weekly 30-minute engineering knowledge-sharing session — tech talks, post-mortems, demos — with 80%+ voluntary attendance for 12 consecutive weeks.

Teams that share knowledge compound their collective competence. Voluntary attendance is proof that it is genuinely valuable.

• Rotate the responsibility for leading each session across the team — ownership increases both preparation quality and attendance.
• After each session, capture the single most useful insight in a shared document — build an institutional knowledge library over time.