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! 🚀

Refactor, Replace, or Respect? Making Peace with Legacy Code

Architecture isn’t just about building new systems; it’s also about living with what came before. Legacy code poses tough questions: Should we refactor it? Replace it? Or simply respect it and build around it? This talk offers a framework for making those decisions with confidence. We’ll explore risk assessment, technical debt prioritization, and the role of business value in shaping technical strategy. Attendees will leave with practical decision-making models for when-and how-to act on legacy code, and how to balance architecture ideals with business realities.

Beyond Lambda: Serverless Pitfalls Nobody Warns You About

Serverless offers scalability and reduced overhead but has hidden pitfalls like architectural traps, cost issues, debugging challenges, cold starts, and more. This talk explores these realities using real-world examples. Learn why infinite scalability isn't always achievable, how architecture changes impact costs, serverless observability, managing state, and the human factors of team skills and vendor lock-in. This session is for developers, DevOps engineers, and architects to help them design serverless applications effectively and avoid common mistakes.

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.

Beyond Copilot: 3 AI-Powered Pull Request Automations That Boost Team Collaboration

AI tools like GitHub Copilot help us write code faster but what about reviewing it, understanding it, and collaborating better as a team? In this talk, we'll go beyond code completion and share three real-world AI automations we use in our pull request workflow to improve communication, reduce friction, and ship with more confidence. You’ll see how we use LLMs to auto-summarize PRs, highlight potential reviewer mismatches, and generate human-friendly change notes - plus the lessons we’ve learned along the way. Whether you're a developer, team lead, or DevOps engineer, you’ll leave with practical ideas for leveling up your team’s PR process with AI.

Target audience: Developers, team leads, engineering managers, DevOps engineers, and tooling enthusiasts.

Technical requirements: Projector with audio. Optional live demo (requires internet access).

Preferred session duration: 30–45 minutes (can adapt to lightning or full session).

Conference fit: Ideal for DevOps, AI-in-engineering, productivity, and team collaboration tracks.

Beyond Copilot: Smarter PR Workflows with AI

Writing code is only half the battle - getting it reviewed, understood, and merged is where teamwork really matters. In this session, we'll explore how our team uses three AI-driven automations to streamline pull requests, improve collaboration, and make code review less painful. From context-aware PR summaries to AI-suggested reviewers and change impact descriptions, you'll get a behind-the-scenes look at how we integrated large language models into our dev process. If you're excited about practical AI that improves how developers work together - not just how they code - this talk is for you.

Target audience: Hands-on developers, software architects, open source contributors, and productivity-focused teams.

Technical requirements: Slides + optional live code snippets (no complex infra).

Preferred session duration: 40 minutes ~

Conferences considered: Developer-first events like GitHub Universe, DevOpsDays, LeadDev, JSConf, React Summit, and similar.

Building Success Brick by Brick: The Art of Achievable Daily Goals

Overcommitting to tasks may cause frustration, missed deadlines, and excessive coffee consumption.
In Agile practice, the difference between aspiration and delivery often comes down to how well we define our daily tasks. This talk explores a practical technique for turning complex objectives into small, achievable goals, using the metaphor of building with LEGO bricks. Just as a LEGO model emerges from clear, interlocking pieces, team success grows from well-structured, deliverable tasks.

We will walk through a simple framework for breaking down goals into actionable units, aligning them with team capacity, and fostering a sense of accomplishment. The session emphasizes the importance of clarity, measurability, and incremental progress in enabling team members to commit confidently, and succeed consistently.

target audience: engineering managers
45 mins