Improve Engineering Efficiency with LinearB

Planning iterations accurately and delivering on promises is impossible if Cycle Time is too long (think the majority of a sprint). The biggest drag on Cycle Time? PR idle time.
And half of PRs are idle for 50.4% of their lifespan.

How to improve your Cycle Time

Everyone on the team has a part to play at every stage when reducing Cycle Time.

Leadership needs a bird’s eye view into the engineering organization’s performance, its position within the industry, and which parts need to improve. They then need to work with team leads to set goals, track progress, and communicate success to the business.

Team managers need to investigate further, identify bottlenecks, and work with their team to set and track progress on improvement goals.

Developers need to agree to changes, stay informed on goals, and be the agents of change.

Here are the steps to improve engineering efficiency with LinearB:

What informs your Cycle Time?​

DORA defines Lead Time for Changes (a.k.a Cycle Time, a.k.a the best proxy for efficiency) as when work begins (e.g. first commit) to when code is delivered to production and into customers’ hands.

Within that metric there are several phases.

Improve one (or ideally all of them) and watch your efficiency, predictability, and value delivery improve in turn.

Benchmark current performance and define “good” for your team​​

There’s a lot of information to glean from this “home” dashboard. Where work is being done, the different phases of Cycle Time, the team’s workload, etc.--and all of it informs efficiency. At a glance, you can see:
Review time is a Cycle Time bottleneck​
Your team likely has too much work in progress (WIP)​
There’s a lot of code churn happening​

Once you have a high level understanding of your team’s efficiency, get some additional context and see where you are using our engineering benchmarks.

Ultimately, you know your team and your code base better than we do. Come up with your definition of good based on your current performance, priorities, objectives, and what’s realistic.

Find your specific bottlenecks​​

Once a definition of good for efficiency metrics is agreed upon, it’s time to look for your leading indicators of inefficiency.

For many teams, the leading indicator of high review time (and Cycle Time) is PR size. Determining whether a team is efficient often comes down to whether they break work down into manageable chunks or not. When PRs are small they:

Get picked up more quickly​
Make reviews faster and more thorough ​
Reduce context switches and cognitive load​
Shorten time between handoffs​
When you see a high review time (lagging indicator), the PR size may be the root cause/leading indicator.

Other leading indicators

Process bottlenecks lead to idle time and are major contributors to engineering inefficiency--things like:
High rates of code churn​
Overloaded team members (lots of WIP)​
Unbalanced sprints (too much code time, too little review time)​

Only after these issues are uncovered is the whole picture of the team’s performance complete. Team leads can then surface these issues in their recurring ceremonies and ensure everyone is aware.

After that, engineering leaders and team leads can work together to come up with an improvement plan that incorporates tangible, measurable goals and low-friction tools to drive best practices.

Pulse - moment in time look into work at risk, churn, WIP and overall iteration health

Ready to reduce PR idle time and
improve efficiency?​

Get Started

Create your improvement plan​

A common pitfall when attempting to improve processes is lack of communication and alignment. Initiatives and goals won’t succeed if the team isn’t aware, aligned, and accepting.

Once team leads have baselined efficiency metrics, gotten a sense of where they stand, and discovered cycle time bottlenecks (spoiler alert: it’s probably pull request size), it’s time to take action.

Focus on one or two bottlenecks--PR size and review time, for instance--and build your plan around them.

Step 1: Bring data for past performance to next retro and align the team​
Step 2: Give them context into performance by using the engineering benchmarks
Step 3: With the team, set goals to improve one “tier” over the next 2-3 iterations (e.g. from “Fair” to “Strong”). ​
Step 4: Come up with a cadence for checking in on progress --repurpose existing ceremony or set time aside specifically for goals.​

LinearB automates away the overhead of goal setting and tracking--no more time spent with spreadsheets and manually generating reports.

Automate and track improvement​

Once your plan is in place, it’s time to take action. Remember that developers are the agents of change and the ones who will drive efficiency improvements — you need to give them a low friction way to execute.

LinearB offers several tools to keep the team aligned and moving toward the same objective:

Use WorkerB team alerts to keep team goals for PR size, at-risk work, and review time on developers’ minds
Give developers a way to move their work through the development cycle faster and with less cognitive load with WorkerB personal
The team Goals dashboard is ideal for checking in on progress--use it for mid-sprint syncs, retros, and planning sessions
The Metrics tab is great for a more zoomed out, The highly customizable view of the team (or the organization as a whole) to see trends and progress over several iterations

Use WorkerB, Goals, and Metrics in concert and regularly analyze and adjust them based on your team’s capabilities and working agreements.

Ultimately, progress on improving engineering efficiency should be thought of as iterative and dynamic--There is no “finish line.”

The benefits of increasing
engineering efficiency with LinearB​

For developers
Spend more time coding and less time playing PR ping pong​
Minimize interruptions and increase focus with automation​
Build, merge, and ship higher quality code, faster​
For managers
Decrease cycle time, ship more features, and deliver more value​
Remove common blockers and developer toil​
Plan sprints more accurately with reduced carryover due to long reviews​
For leaders
Push code through development cycle faster for more feature delivery​
Deliver on promises to the business​
Empower developers to become elite and deliver more business value​

Improvements that you can
see with LinearB​

Want to bring some efficiency
data to your next sync?​

Get started

Improve Code Quality

Curious about how your team can start writing better code using LinearB?​
Explore Next

Stories and Studies

See why engineering teams love using LinearB to improve
Learn More

Surviving SVB’s Collapse & Outsmarting Uber
Join our Dev Interrupted Livestream with Kyte’s Head of Product and Engineering, Nick Cobb