How To Optimize The Software Development Workflow

Systems Thinking: The Productivity Paradox Imagine a riverside town struggling with seasonal flooding. To mitigate, they build higher levees, allowing them to expand housing and businesses into previously flood-prone areas. At first, flooding stops, and the town thrives. But over time, wetlands downstream erode, and floodwaters have nowhere to spread. When a major storm overwhelms the levees, the flooding is worse than ever. More levees and expansion seemed like progress… but the system fought back. Now, imagine a software company struggling with slow delivery. Customers complain. Revenue and reputation are at risk. Executives need a fix. Their answer? Hire more developers. At first, velocity increases. Features ship faster. But soon, delivery is slower than before the new team members were hired. Adding devs was supposed to speed things up (and did, briefly). But… the system fought back. Why Adding Developers Slows Things Down Fred Brooks wrote, “Adding manpower to a late software project makes it later.” Why? Communication grows exponentially. With 5 devs, you manage 10 communication links. With 10, it’s 45. At 20, it’s 190. More meetings, more dependencies, slower decisions. New hires aren't immediately productive. Senior devs have to help with onboarding. As the team grows, more code is written, leading to merge conflicts, longer pull request cycles, and WIP stuck in queues. More teams means unclear ownership, more handoffs, and more rework. What's The Solution? 1) Reduce WIP Too much WIP slows teams down. Before hiring, ask: Are we prioritizing finishing over starting? Can we reduce batch sizes? Can we use Kanban and/or Scrum to improve flow without adding people? 2) Think Structure, Not Size More devs means higher coordination costs. Instead, use Team Topologies. Stream-aligned teams own end-to-end delivery. Enabling teams improve developer focus. Platform teams reduce cognitive load. 3) Automate and Improve Code Quality Don't maximize team size, optimize the pipeline. Faster CI/CD reduces delays, automated testing prevents bug creep, and refactoring improves maintainability. 4) Use Modular Architecture A tightly coupled system slows everyone down. Shift to microservices or modular monoliths (single deployable units), use feature flags for incremental deployment, and apply domain-driven design (DDD) to define team boundaries. 5) Measure Outcomes, Not Headcount Leaders may wrongly assume more developers means more output, but real productivity is about flow efficiency. Instead of team size, track: Cycle time (how long it takes to ship), Deployment frequency (how often we deliver), and Lead time for changes (how fast we adapt). Systems, Not Silos When teams slow down, hiring feels like the obvious fix. But it should be the last resort, not the first instinct. Without systems thinking, hiring may have unintended consequences that ironically make things worse. Rethink how your system works... before the next storm.

𝗛𝗼𝘄 𝗜’𝗱 𝗕𝘂𝗶𝗹𝗱 𝗮𝗻 𝗦𝗗𝗩 𝗣𝗹𝗮𝘁𝗳𝗼𝗿𝗺 𝗧𝗼𝗱𝗮𝘆 (𝗪𝗶𝘁𝗵𝗼𝘂𝘁 𝗟𝗼𝘀𝗶𝗻𝗴 𝗠𝘆 𝗠𝗶𝗻𝗱) —𝘮𝘺 𝘱𝘦𝘳𝘴𝘰𝘯𝘢𝘭 𝘷𝘪𝘦𝘸; 𝘰𝘱𝘪𝘯𝘪𝘰𝘯𝘴 𝘢𝘳𝘦 𝘮𝘺 𝘰𝘸𝘯. 𝗧𝗵𝗲 𝗙𝗼𝘂𝗻𝗱𝗮𝘁𝗶𝗼𝗻 “𝘈𝘳𝘤𝘩𝘪𝘵𝘦𝘤𝘵𝘶𝘳𝘦 𝘪𝘴 𝘺𝘰𝘶𝘳 𝘧𝘪𝘳𝘴𝘵 𝘵𝘦𝘴𝘵 𝘤𝘢𝘴𝘦. 𝘍𝘢𝘪𝘭 𝘩𝘦𝘳𝘦, 𝘢𝘯𝘥 𝘦𝘷𝘦𝘳𝘺 ‘𝘧𝘪𝘹’ 𝘣𝘦𝘤𝘰𝘮𝘦𝘴 𝘵𝘦𝘤𝘩𝘯𝘪𝘤𝘢𝘭 𝘥𝘦𝘣𝘵.” 𝟳 𝗖𝗿𝗶𝘁𝗶𝗰𝗮𝗹 𝗦𝘁𝗲𝗽𝘀 (𝗮𝗻𝗱 𝗪𝗵𝘆 𝗧𝗵𝗲𝘆 𝗠𝗮𝘁𝘁𝗲𝗿) 𝟬. 🏗️ 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁 𝗼𝗿 𝗦𝘂𝗳𝗳𝗲𝗿 No Franken‑ECUs. Define blocks, constraints, and absolute 𝗡𝗢𝘀 up‑front. → “𝘐𝘧 𝘪𝘵 𝘣𝘳𝘦𝘢𝘬𝘴 𝘵𝘩𝘦 𝘢𝘳𝘤𝘩𝘪𝘵𝘦𝘤𝘵𝘶𝘳𝘦, 𝘪𝘵 𝘥𝘰𝘦𝘴𝘯’𝘵 𝘴𝘩𝘪𝘱.” 𝟭. 🚦 𝗦𝗮𝗳𝗲𝘁𝘆 / 𝗦𝗲𝗰𝘂𝗿𝗶𝘁𝘆: 𝗧𝗵𝗲 𝗕𝗮𝗿𝗲 𝗠𝗶𝗻𝗶𝗺𝘂𝗺 Not a phase — it’s your entry ticket. MPU, crypto, E2E in CI from Day 1. “𝘏𝘰𝘱𝘦 𝘪𝘴𝘯’𝘵 𝘢 𝘵𝘩𝘳𝘦𝘢𝘵 𝘮𝘰𝘥𝘦𝘭.” 𝟮. ⚡ 𝗗𝗲𝗰𝗼𝘂𝗽𝗹𝗲 𝗼𝗿 𝗗𝗶𝗲 𝗧𝗿𝗮𝗻𝘀𝗽𝗼𝗿𝘁 = 𝗔𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻. Stress‑test separately:  • Apps ride on a “dumb pipe” first.  • Transport survives network hell (latency spikes, packet carnage). 𝟯. 🧩 𝗥𝘂𝗻𝘁𝗶𝗺𝗲 𝗔𝗴𝗻𝗼𝘀𝘁𝗶𝗰𝗶𝘀𝗺 𝗗𝗼𝗻𝗲 𝗥𝗶𝗴𝗵𝘁  • Abstraction layer is 𝗺𝗮𝗻𝗱𝗮𝘁𝗼𝗿𝘆 for application dev.  • Runtime optimization happens underneath (apps stay binary‑compatible).  • Clear constraints per deployment:  • “Need hard real‑time? The runtime must guarantee it—no exceptions.” 𝟰. 🔧 𝗧𝗼𝗼𝗹𝘀: 𝗗𝗲𝗳𝗶𝗻𝗲 𝗢𝗻𝗰𝗲, 𝗙𝗼𝗹𝗹𝗼𝘄 𝗥𝗶𝗴𝗼𝗿𝗼𝘂𝘀𝗹𝘆  • Standardize toolchain early (simulators, CI, analyzers).  • New tools? Budget for disruption—3× the cost you expect. “𝘚𝘪𝘮𝘶𝘭𝘢𝘵𝘪𝘰𝘯 𝘪𝘴 𝘫𝘶𝘴𝘵 𝘰𝘯𝘦 𝘸𝘦𝘢𝘱𝘰𝘯. 𝘙𝘦𝘢𝘭 𝘌𝘊𝘜𝘴 𝘥𝘰𝘯’𝘵 𝘭𝘪𝘦.” 𝟱. 🧪 𝗧𝗲𝘀𝘁 𝗟𝗶𝗸𝗲 𝘁𝗵𝗲 𝗩𝗲𝗵𝗶𝗰𝗹𝗲 𝗜𝘀 𝗪𝗮𝘁𝗰𝗵𝗶𝗻𝗴 Pyramid or perish: 𝗨𝗻𝗶𝘁 → 𝗦𝗪 → 𝗛𝗪 → 𝗩𝗲𝗵𝗶𝗰𝗹𝗲. “𝘓𝘢𝘣‐𝘱𝘦𝘳𝘧𝘦𝘤𝘵 = 𝘙𝘰𝘢𝘥‐𝘳𝘦𝘢𝘥𝘺” (EMI, 40 °C to ‑30 °C, vibration torture). “𝘐𝘧 𝘪𝘵 𝘧𝘢𝘪𝘭𝘴 𝘰𝘯 𝘢𝘴𝘱𝘩𝘢𝘭𝘵, 𝘺𝘰𝘶 𝘥𝘪𝘥𝘯’𝘵 𝘵𝘦𝘴𝘵—𝘺𝘰𝘶 𝘨𝘢𝘮𝘣𝘭𝘦𝘥.” 𝟲. 🤝 𝗜𝗻𝘁𝗲𝗴𝗿𝗮𝘁𝗶𝗼𝗻 𝗯𝘆 𝗗𝗲𝘀𝗶𝗴𝗻 Not a phase—part of the blueprint. “𝘕𝘰 𝘣𝘦𝘯𝘤𝘩 𝘱𝘳𝘰𝘰𝘧? 𝘐𝘵’𝘴 𝘷𝘢𝘱𝘰𝘳𝘸𝘢𝘳𝘦.” 𝟳. 📜 𝗣𝗿𝗼𝗰𝗲𝘀𝘀 𝗧𝗵𝗮𝘁 𝗦𝘂𝗿𝘃𝗶𝘃𝗲𝘀 𝗔𝘂𝗱𝗶𝘁𝘀 Hate bureaucracy? Same. But:  • Traceability isn’t optional—ASPICE / ISO 26262 will come knocking.  • Document the 𝗺𝗶𝗻𝗶𝗺𝗮𝗹 𝘃𝗶𝗮𝗯𝗹𝗲 𝘁𝗿𝗮𝗶𝗹:  • Requirements ↔ Design ↔ Test • Changes ↔ Justifications  • “𝘓𝘪𝘨𝘩𝘵𝘸𝘦𝘪𝘨𝘩𝘵 = 𝘚𝘭𝘰𝘱𝘱𝘺. 𝘗𝘳𝘰𝘷𝘦 𝘺𝘰𝘶𝘳 𝘸𝘰𝘳𝘬 𝘰𝘳 𝘧𝘢𝘪𝘭 𝘤𝘦𝘳𝘵𝘪𝘧𝘪𝘤𝘢𝘵𝘪𝘰𝘯.” 𝗧𝗵𝗲 𝗦𝘁𝗿𝗮𝘁𝗲𝗴𝗶𝗰 𝗥𝗲𝗮𝗹𝗶𝘁𝘆  • Your supply chain isn’t a vendor list—it’s an innovation network.  • Co‑design with silicon / ECU partners before freezing architecture.  • Turn “absolute NOs” into joint feasibility studies.  • Multi‑sourcing isn’t just anti‑lock‑in—it’s resilience. “A perfect architecture that ignores supply‐chain realities is just expensive fiction.” #SDV #AutomotiveSoftware #StrategicPartnerships #ZeroCompromise

Yet another reason estimates are ridiculous. One of the silliest things about time estimates is that the vast majority of time it takes for a team to finish something is spent waiting. For the average development team to create something of value, only 10-20% of the total start-to-finish completion time is spent actively working on the item. The majority of the time is spent waiting. 🔵 Waiting for Reviews 🔵 Waiting for team member hand-offs 🔵 Waiting on other teams or departments So much time is spent waiting… instead of asking, “How much time will it take WORKING to complete this?” You’d be better off asking, “How much time will it take WAITING to complete this?” This, of course, is impossible to answer since most teams have zero control (or even awareness) of waiting time. You’re far, far better off ditching time estimates entirely and focusing on reducing wait states instead. But how? 1] Use Flow Efficiency ↳ Few teams are even aware of the most critical flow metric: Flow Efficiency. ↳ Flow Efficiency tells you how much time is spent actively working on increments of value (features, assets, stories, etc.). ↳ Flow Efficiency (%) = Active Time / Total Time X 100 ↳ Any good workflow tool will calculate your Total Time (Cycle Time). 2] Determine Active Time ↳ To figure out Active Time, you need to track your wait states by adding a “Done” state to every existing stage in your workflow. ↳ For Example: Development -> Development Done -> Testing -> Testing Done -> Review -> Review Done -> Released ↳ The “Done” columns are your wait states.  ↳ Now, you can effectively determine Active Time for each item in your flow vs. Wait Time. 3] Improve Flow Efficiency ↳ Once you can visualize and track wait times, you can focus on fixing the worst offenders. ↳ Add team members, reduce work in progress, remove dependencies… there are many ways to minimize wait states. ↳ Any reduction made to any of your wait states will improve Flow Efficiency An average team will have a Flow Efficiency of 20%. Your team should achieve a Flow Efficiency of 40% or greater to be considered high-performing. Will this take some effort? Of course! But far less effort and total team time (and annoyance) than asking for estimates. Plus, the increase in productivity will far outweigh any loss in imagined predictability.

Something cool I realized over the years: you should build process in your company EXACTLY like you build software as an engineer. If you're starting a company or team today and want to build great processes, do what software engineers do, just replace "software" with "process": 1. Start with no process. 2. Make small, frequent updates to your process. Updates should be small but complete. 3. Solve real problems with your updates. - Always start with the most important problems. - Solve bugs and improve quality. - Identify real problems by performing a root cause analysis on events that ACTUALLY happened and that you’re trying to avoid going forward. 4. Push those updates to the machine that executes them. When you make process changes that humans need to follow, always “push it to their 🧠” by notifying them of the process change. 5. Don’t just accumulate processes. Perform “garbage collection”: occasionally reexamine your process and delete what doesn’t serve us anymore. 6. Your process should have one entry point. Every software system has an entry point. Build a central playbook for your team and company and make it the entry point, to ensure that everyone within your team has an entry point into your full process, and doesn't have "blind spots". Going deeper: --- 1. ACTION QUALITY I think about all actions in all processes in 3 categories: 🟢 GUARANTEED: these are actions that are software-controlled, and don't require human discretion. They are executed on 💻 Example: starting 2022, every sandbox sign up at Unit sends a welcome email. 🟡 MOSTLY GUARANTEED: these are actions that happen because we expect people to follow a playbook. We give them feedback and help them develop habits to do it. They are executed on 🧠 Example: in 2021, we had a step within the sales playbook to send a welcome email for every sandbox sign up. 🔴 NOT GUARANTEED: these are actions that are not written in playbooks: implicit expectations, reminders in people’s heads or a message in Slack 2 years ago. They are executed on 🧠 Example: in 2020, I had a reminder in my head to send a welcome email for every sandbox sign up. --- 2. ROOT CAUSE ANALYSIS In the Israeli army, there is a saying that "all rules were written in blood". If you instill a culture of root cause analysis in your company, it will AUTOMATICALLY upgrade your process over time: - Upgrade 🔴 not written in a playbook into 🟡 written in a playbook. - Upgrade 🟡 written in a playbook into 🟢 fully automated. Below is how we like to do root cause analysis at Unit.

Critique this (real) team's experiment. Good? Bad? Caveats? Gotchas? Contexts where it will not work? Read on: Overview The team has observed that devs often encounter friction during their work—tooling, debt, environment, etc. These issues (while manageable) tend to slow down progress and are often recurring. Historically, recording, prioritizing, and getting approval to address these areas of friction involves too much overhead, which 1) makes the team less productive, and 2) results in the issues remaining unresolved. For various reasons, team members don't currently feel empowered to address these issues as part of their normal work. Purpose Empower devs to address friction points as they encounter them, w/o needing to get permission, provided the issue can be resolved in 3d or less. Hypothesis: by immediately tackling these problems, the team will improve overall productivity and make work more enjoyable. Reinforce the practice of addressing friction as part of the developers' workflow, helping to build muscle memory and normalize "fix as you go." Key Guidelines 1. When a dev encounters friction, assess whether the issue is likely to recur and affect others. If they believe it can be resolved in 3d or less, they create a "friction workdown" ticket in Jira (use the right tags). No permission needed. 2. Put current work in "paused" status, mark new ticket as "in progress," and notify the team via #friction Slack channel with a link to the ticket. 3. If the dev finds that the issue will take longer than 3d to resolve, they stop, document what they’ve learned, and pause the ticket. This allows the team to revisit the issue later and consider more comprehensive solutions. This is OK! 4. After every 10 friction workdown tickets are completed, the team holds a review session to discuss the decisions made and the impact of the work. Promote transparency and alignment on the value of the issues addressed. 5. Expires after 3mos. If the team sees evidence of improved efficiency and productivity, they may choose to continue; otherwise, it will be discontinued (default to discontinue, to avoid Zombie Process). 6. IMPORTANT: The team will not be asked to cut corners elsewhere (or work harder) to make arbitrary deadlines due to this work. This is considered real work. Expected Outcomes Reduce overhead associated with addressing recurring friction points, empowering developers to act when issues are most salient (and they are motivated). Impact will be measured through existing DX survey, lead time, and cycle time metrics, etc. Signs of Concern (Monitor for these and dampen) 1. Consistently underestimating the time required to address friction issues, leading to frequent pauses and unfinished work. 2. Feedback indicating that the friction points being addressed are not significantly benefiting the team as a whole. Limitations Not intended to impact more complex, systemic issues or challenges that extend beyond the team's scope of influence.

Last week, I cut a team’s delivery time from 14 days to 3. No new tools. No new hires. Most “best practices” are just busywork. I proved it in under a week. This was inside a global consumer brand. The kind where 6 departments want signoff before anything moves. The team thought every step was necessary. But most were just legacy habits. They were clinging to steps they couldn’t even explain. ___________________________________________ So I mapped out the process with them: - We looked at every step, one by one. - I asked: “Why do we do this?” - No clear answer? We cut it. What I found was that most of the 14 days weren’t spent prepping assets. They were spent waiting on feedback, file uploads, people to open emails and approvals from multiple departments. Once we stripped the unnecessary steps, here’s what the new flow looked like: One portal. One timeline. Inline comments. Instant download. Done. ___________________________________________ We removed 7 steps. Seven. Gone. Just by fixing the flow. Now the work, flows. The team moves faster. And no one’s gasping for air by Thursday If your workflow feels heavy and slow, try this: → List your steps. → Ask: “Does this actually move us forward?” → If not, cut it. You don’t need more time. You need fewer steps. Keep it lean Was this helpful? ___________________________________________ PS: I share the juicy stuff in my comment section

Struggling to keep your software projects on track? 😕 Misunderstandings in the early stages of development can send even the best teams into costly cycles of rework. Imagine a process where everything is clear from the get-go. Right at the outset, QA teams, including automation engineers and manual testers, can craft test cases in plain English. This approach isn't just about efficiency, it's about setting your project up for success from day one. By establishing all crucial functionality early, this method dramatically streamlines the entire development cycle. It eliminates the chaos and keeps everyone aligned on the project goals. With clear and detailed specifications from the start, engineers receive a roadmap that significantly reduces the need to backtrack and rewrite. This not only saves time but also conserves valuable resources. The payoff? You could see up to a 𝟑𝟓% 𝐬𝐚𝐯𝐢𝐧𝐠𝐬 𝐢𝐧 𝐞𝐧𝐠𝐢𝐧𝐞𝐞𝐫𝐢𝐧𝐠 𝐭𝐢𝐦𝐞, thanks to a drastic reduction in misinterpretations and overlooked details. Let’s rethink the effectiveness of our initial development stages. What could your team achieve with all that recovered time? #SDLC #QualityAssurance #SoftwareDevelopment #AITestingTools

Who cares about quality if the bad code works? The problem is that the majority of the cost of the Software is not in its initial development; But in its ongoing maintenance! 5 ways to improve your system maintainability that will make your life easy. 𝟭. 𝗥𝗲𝗴𝘂𝗹𝗮𝗿 𝗥𝗲𝗳𝗮𝗰𝘁𝗼𝗿𝗶𝗻𝗴 You should be refactoring every day. - Remove code smells - Improves code readability - Enhances system maintainability It's an investment that pays off in reduced maintenance costs. 𝟮. 𝗔𝗱𝗼𝗽𝘁 𝗖𝗼𝗱𝗶𝗻𝗴 𝗦𝘁𝗮𝗻𝗱𝗮𝗿𝗱𝘀 Establish and enforce coding standards within your development team. Consistent code style and conventions make the codebase more readable and maintainable. This will reduce the time spent understanding and modifying legacy code. New code should look like existing code! 𝟯. 𝗠𝗼𝗱𝘂𝗹𝗮𝗿𝗶𝘇𝗲 𝘁𝗵𝗲 𝗖𝗼𝗱𝗲𝗯𝗮𝘀𝗲 Break down the system into smaller, reusable components. Modularization improves code organization and separation of concerns. It's better for: - Easier maintenance - Bug fixing - Future feature additions - Reducing development efforts 𝟰. 𝗔𝘂𝘁𝗼𝗺𝗮𝘁𝗲𝗱 𝗧𝗲𝘀𝘁𝗶𝗻𝗴 Invest in robust test suites to catch bugs and regressions early. Automated tests provide confidence during maintenance activities, allowing developers to make changes. They safeguard the system's integrity and save time in the long run. 𝟱. 𝗗𝗼𝗰𝘂𝗺𝗲𝗻𝘁 Documentation helps in understanding the system and expedites onboarding new team members. - System Architecture - Design decisions - Important code segments Investing in system maintainability reduces the cost and effort of maintaining legacy software. You will have to work daily in those systems, so it is not all about your software. Improving maintainability, it will make your life easy.

Software version numbers and git branches are tricky monsters to tame. Taming them becomes CRITICAL as members are added to your development team. Not taming them becomes CATASTROPHIC as more software versions are released to more customers. Implement a workflow that HELPS your software development team, IMPROVES their ability to collaborate, and PROMOTES clear software version numbers for end users. Version management MUST be implemented thoughtfully. > Should not frustrate developers. > Should not drastically increase developers' workloads. > Must be self-rewarding so that developers have a selfish interest in adhering to the workflow. Rules for Git MUST be put in place. > Random branch names are confusing. > Understanding when/why to create a new branch removes unnecessary clutter. > Development & Feature Branches make for easy team collaboration. > A micro-commit workflow should be adhered to. !! Quick Workflow Overview !! 1. Fetch & merge the master/main branch. 2. Determine the next Deployment Version Number.    a. The Deployment Version Number follows the “X.Y.Z” scheme. 3. Derive the Development Version Number from the Deployment Version Number.    a. The Development Version Number follows the “X.Y.Z-dev” scheme. 4. Create or fetch & merge the Development Branch. 5. Update the Software Version Number to the Development Version Number. 6. Develop all features.    a. Each feature gets its own branch and version number.    b. Feature Development Version Numbers follow the “X.Y.Z-dev-[Feature Name/Description]” scheme.    c. Adhere to the Micro-Commit Workflow. 7. In preparation for deployment, coordinate with other developers to ensure no more changes are made to the Development Branch. 8. Fetch & merge the Development Branch. 9. Fetch & merge the master/main branch. 10. Merge the local master/main branch into the Development Branch. 11. Prepare for deployment by creating a new Deployment Branch and changing the Software Version Number. 12. Publish the Deployment Branch