How to Optimize Non-Coding Time

This talk is unique because 99% of developer productivity tools and hacks are about coding faster, better, smarter. And yet the vast majority of our time is spent doing all of this other stuff. After I started focusing on optimizing the 10 hours I spend every day on non-coding tasks, I found I my productivity went up and my frustration at annoying stuff went way down.

I cover how to save time by reducing cognitive load and by cutting menial, non-coding tasks that we have to perform 10-50 times every day. For example:

Bug or hotfix comes through and you want to start working on it right away so you create a branch and start fixing. What you don’t do is create a Jira ticket but then later your boss/PM/CSM yells at your due to lack of visibility. I share how I automated ticket creation in Slack by correlating Github to Jira.

You have 20 minutes until your next meeting and you open a pull request and start a review. But you get pulled away half way through and when you come back the next day you forgot everything and have to start over. Huge waste of time. I share an ML job I wrote that tells me how long the review will take so I can pick PRs that fit the amount of time I have.

You build. You ship it. You own it. Great. But after I merge my code I never know where it actually is. Did the CI job fail? Is it release under feature flag? Did it just go GA to everyone? I share a bot I wrote that personally tells me where my code is in the pipeline after it leaves my hands so I can actually take full ownership without spending tons of time figuring out what code is in what release.

Pull Request Size: The Most Important Indicator of Development Pipeline Health

Accelerate popularized “DORA 4” metrics for tracking the health of your dev pipeline. I studied 2,600 teams and found a single indicator that predicts if your team’s metrics will be elite. Learn why small PR size is the key to healthy cycle time, MTTR, change failure rate and deploy frequency.

This presentation includes industry benchmarks from 2,600 dev teams collected from January 2020 though June 2021, all of the data and citations from my research, multiple case studies from well known Israeli start-ups like Unbabel, Intsights and BigID and tips for improving PR size, cycle time, MTTR, change failure rate and deployment frequency.

From CI/CD to CM (Continuous Merge): Unleash Your Dev Velocity

Being an elite dev team isn’t just about merging faster, it’s about being able to deliver consistently. While velocity is the primary metric these days that marks elite teams - this is still in a world where all pull requests are created equal and undergo the same CI/CD gating and branch protection. But what if it doesn’t have to be this way?

Developer happiness and retention is often based on the type of work a team is doing and the amount of frustration involved trying to get code merged––where some of these merges are as simple as minor config fixes, version upgrades or documentation edits. In this session, we will discover how elite teams are flipping the paradigm through evolving their CI/CD to CM, continuous merge, by optimizing non-coding time and customizing how Pull Requests are treated based on their unique characteristics and impact on production systems. You too can be one pull request away from dev enlightenment and happiness.

Dev Team Metrics that Matter

What is the most valuable outcome? This is the most important question to answer before starting an engineering metrics program. In this talk I discuss which dev team metrics matter most, the outcome they produce, and pitfalls to avoid when starting a metrics initiative.

The truth is, no one really likes being measured, especially devs. But business leaders like looking at numbers, so they grab what’s easily available - # of code changes, agile velocity, individual dev metrics. These types of metrics are unbalanced, exclude context, and hurt engineering culture as a whole.

What you measure is what your team will produce. If you start measuring the number of code changes as a key performance metric, you are going to see coding time, PR size, and Cycle Time all increase.

Don’t fall into this trap.

In this session I discuss which team level metrics are most significant, the outcomes they produce, and strategies that will help you avoid the mistakes I’ve already made.

Cycle Time and Nap Time: What Baby Routines Teach Us About Developer Efficiency

At first glance, a baby’s daily routine and a developer's cycle time might seem worlds apart—but both rely on structure, predictability, and minimizing bottlenecks. Just as missed naps or delayed feeding can create cascading chaos in a baby’s day, blockers and inefficiencies in the development cycle can derail an entire sprint. In this talk, we’ll draw surprising parallels between optimizing a baby’s daily schedule and streamlining developer workflows. From identifying patterns and dependencies to managing context-switching and recovery time, you’ll discover actionable insights that can improve both your team's efficiency and your home life. Whether you're a parent, a tech leader, or both, this session will leave you with fresh perspectives on managing cycles—be they naptime or deployment pipelines.

Discover surprising parallels between a baby’s routine and developer workflows. Learn actionable strategies to optimize cycles, minimize chaos, and boost efficiency—whether managing naptime schedules, sprints, or both. Fresh insights for parents and tech leaders alike!

50 shades of PR

In this short and fun talk (yes it’ll be fun!) - Avishag Sahar laments about the top blockers of PRs, but cheer up - because I’ll also provide insights into how to unblock them.

Relevant to software engineers, manager and tech leader!

It’s Not Always About the Index: The Hidden Secrets of Query Performance

Indexes are often hailed as the silver bullet for slow queries—but what if they aren’t the answer? In this talk, we’ll debunk the myth that adding an index is always the best solution and dive into the hidden performance killers lurking in your database. From inefficient query patterns and misused joins to transaction overhead and bloated statistics, we’ll explore real-world scenarios where indexes failed and smarter alternatives prevailed. Expect live demos, surprising insights, and actionable takeaways to help you optimize queries beyond just adding another index. Whether you're a database veteran or a curious dev, this talk will make you rethink how you approach query performance! 🚀

This talk is for developers who don’t work with databases frequently. It may include a live demo.