Software Development Lifecycle In Engineering

Last month, engineering leads at Duolingo held our first “engineerication.” (I got the idea from Stripe.) Basically, we took a week off from our regular jobs to sit together and code in order to see what our engineers do daily, get back into the tech stack to see what can be improved. 👩💻 Turns out, a lot has changed in the years since I last wrote a line of code 😅Some things have gotten much easier. Codespaces, for example, allows engineers to easily create a coding environment in the cloud instead of on their local machines. And GitHub Copilot auto-suggests chunks of code. But there were 3 big takeaways I had for how we can improve our engineers’ experiences: 1. On the first day, I set out to do a few small code changes. But as a new engineer, you can’t just sit down and make a change immediately, even a tiny one. You have to set up your environment and figure out where the code needs to go. Then you have to build the code, test it, get it reviewed, and push it live to production. All of this takes time—sometimes, too much time. I want to make it easy for new software engineers to be productive right away without having to set up their development environment or having to learn a lot of arcane tools, processes, and magical incantations. 2. When I started at Duolingo nine years ago, we had a few GitHub repositories. Now we have dozens of microservices. This means that even a small code change may require updates to several repositories. If you’re not regularly working in a given repo, this is much harder, especially if it’s one that your team doesn't own. More standardization is needed to make it easier to code across our various microservices and client repos (we’re starting to do this, but more can be done!) 3. Code review turnaround time slowed us down. We averaged about a 24-hour turnaround, but when making atomic (easily revertable) pull requests, lots of PRs stack up and eventually lead to merge conflicts, etc. In practice, I could see engineers cutting their turnaround time by making PRs that are less atomic, which leads to messier reverts and a harder time diagnosing bugs. Whenever software engineers are tempted to take shortcuts because the current process is too slow or painful, that’s an opportunity for improvement. Overall, taking a week to go hands-on with the code is a great way to build better processes and teams. It was an incredibly valuable week that helped us visualize the steps we can take to remove pain points and speed up some unnecessarily slow processes. 🐢 (One more learning: Next time, I’m going to invite one of our software engineers to pair program with me 😅) Help us develop new products and processes! We're hiring: https://lnkd.in/eSJYjYPG #engineering #processimprovement #leadershipidea

"Vibe Coding !== Low Quality Work: a guide to responsible AI-assisted dev" ✍️ My latest free article: https://lnkd.in/gjMdjMWV The allure of "vibe coding" – using AI to "move faster and break even more things" – is strong. AI-assisted development is undeniably transformative, lowering barriers and boosting productivity. But speed without quality is a dangerous trap. Relying uncritically on AI-generated code can lead to brittle "house of cards" systems, amplify tech debt exponentially, and introduce subtle security flaws. Volume ≠ Quality. A helpful mental model I discuss (excellently illustrated by Forrest Brazeal) is treating AI like a "very eager junior developer." It needs guidance, review, and refinement from experienced hands. You wouldn't let a junior ship unreviewed code, right? So how do we harness AI's power responsibly? I've outlined a field guide with practical rules: ✅ Always review: Treat AI output like a PR from a new hire. ✅ Refactor & test: Inject engineering wisdom – clean up, handle edge cases, test thoroughly. ✅ Maintain standards: Ensure AI code meets your team's style, architecture, and quality bar. ✅ Human-led design: Use AI for implementation grunt work, not fundamental architecture decisions. The goal isn't to reject vibe coding, but to integrate it with discipline. Let's use AI to augment our craft, pairing machine speed with human judgment. #softwareengineering #programming #ai

I have put together this DevOps Metrics infographic - it's like a cheat sheet for keeping your finger on the pulse of your entire development pipeline. Let's break it down- We start with the "Plan" phase - because hey, failing to plan is planning to fail, right? 😉 We're talking Sprint Burndown, Team Velocity, and even Epic Burndown. These metrics help you understand if your team is biting off more than they can chew or if they're ready to take on more challenges. Moving on to "Code" - this is where the rubber meets the road. Code Reviews, Code Churn, Technical Debt - these aren't just buzzwords, folks. They're vital signs of your codebase's health. And don't get me started on the importance of Maintainability Index! The "Build" and "Test" phases are where things get real. Build Success Rate, Test Coverage, Defect Metrics - these are your early warning systems. They'll tell you if you're building on solid ground or if you're in for a world of hurt down the line. Now, "Release" and "Deploy" - this is where many teams start sweating. But with metrics like Release Duration, Deployment Frequency, and Change Failure Rate, you can turn this nail-biting phase into a smooth, predictable process. Finally, "Operate" and "Monitor" - because your job isn't done when the code hits production. Customer Feedback, System Uptime, Mean Time to Detect and Repair - these metrics ensure you're not just shipping code, but delivering value. The best part? I've included some of the go-to tools for each phase. Jira, GitHub, Gradle, Jenkins, Docker, Kubernetes - these aren't just fancy names, they're the workhorses that'll help you track these metrics without losing your mind. Remember, folks - you can't improve what you don't measure.

The key to progress on hard, complex projects comes down to latency and bandwidth — the interfaces through which teams communicate. 1 / Latency is the delay. How long it takes for information to travel, decisions to be made, or problems to surface. High latency slows everything down — people wait, guess, or lose momentum. Strong leaders reduce latency by creating environments where: Feedback moves quickly. Problems are flagged early and acted on decisively. Communication loops are short, direct, and clear. 2 / Bandwidth is the capacity. How much information can flow between people. Low bandwidth leads to confusion, blind spots, and misalignment. Strong leaders increase bandwidth by ensuring: Teams share the right context at the right time. Communication is open, transparent, and efficient. People trust each other enough to exchange ideas freely. When latency is low and bandwidth is high, progress accelerates. Teams collaborate seamlessly. Small signals get noticed before they become big problems. Decision-making improves. Great leaders don’t just manage — they optimize the interfaces of communication within the team. They create systems where ideas flow, feedback happens in real time, and no one is stuck waiting for clarity. Because in the end, the speed and quality of progress aren’t just about individual talent — they’re about how well the team interacts. Thoughts??? If you’re building hard things and want signal over hype, subscribe to Per Aspera. 👉🏻 Join here: https://lnkd.in/gacTgUkh

Was asked what my "Sprint planning secret" was. My secret is to do something effective instead of a fake-Agile waterfall-planning session complete with SWAG story-point estimates and tactical planning—something that makes no room for learning as we work. Instead, pick a single story. Keep asking "Can we make this smaller?" until the answer is no. (Most teams don't know what "small" actually is, so they'll have to learn how to do this.) Throw out any of those small stories that aren't worth doing (the best way to get faster is to not build stuff nobody wants), and put all but the most valuable of the stories back on the backlog. Build that most valuable thing. Given that a story represents a customer's problem, not a solution (another thing fake-Agile shops get wrong), sit down with your product people and, ideally, a representative customer and collect enough information to START (not finish) the work. One customer is enough (you've got to start somewhere)—release to more customers and adjust once you've got something concrete in your hands. Continuously collect additional information and feedback as you work with very small incremental releases to skin-in-the-game customers. Better yet, get rid of Sprints altogether. There's some value in doing some things on a regular cadence, but doing everything on the same cadence seems ineffective to me.

🌍 The Real Reason Your Team Isn’t Connecting Might Surprise You 🛑 You’ve built a diverse team. Communication seems clear. Everyone speaks the same language. So why do projects stall? Why does feedback get misread? Why do brilliant employees feel misunderstood? Because what you’re facing isn’t a language barrier—it’s a cultural one. 🤔 Here’s what that looks like in real life: ✳ A team member from a collectivist culture avoids challenging a group decision, even when they disagree. ✳ A manager from a direct feedback culture gets labeled “harsh.” ✳ An employee doesn’t speak up in meetings—not because they don’t have ideas, but because interrupting feels disrespectful in their culture. These aren't missteps—they’re misalignments. And they can quietly erode trust, engagement, and performance. 💡 So how do we fix it? Here are 5 ways to reduce misalignments and build stronger, more inclusive teams: 🧭 1. Train for Cultural Competence—Not Just Diversity Don’t stop at DEI 101. Offer immersive training that helps employees navigate different communication styles, values, and worldviews. 🗣 2. Clarify Team Norms Make the invisible visible. Talk about what “respectful communication” means across cultures. Set expectations before conflicts arise. 🛎 3. Slow Down Decision-Making Fast-paced environments often leave diverse perspectives unheard. Build in time to reflect, revisit, and invite global input. 🌍 4. Encourage Curiosity Over Judgment When something feels off, ask: Could this be cultural? This small shift creates room for empathy and deeper connection. 📊 5. Audit Systems for Cultural Bias Review how you evaluate performance, give feedback, and promote leadership. Are your systems inclusive, or unintentionally favoring one style? 🎯 Cultural differences shouldn’t divide your team—they should drive your innovation. If you’re ready to create a workplace where every team member can thrive, I’d love to help. 📅 Book a complimentary call and let’s talk about what cultural competence could look like in your organization. The link is on my profile. Because when we understand each other, we work better together. 💬 #CulturalCompetence #GlobalTeams #InclusiveLeadership #CrossCulturalCommunication #DEIStrategy

Do you feel part of a real team? Or are there moments when you feel isolated, uncertain, and disconnected, even though you're surrounded by colleagues? In the early stages of my career, I had the simplistic view that bringing together a bunch of high achievers would naturally create an outstanding team. However, the reality was quite different. Instead of creating synergy, there was noticeable discord. The team didn't seem to gel; it was akin to cogs not aligning in a machine. Every top performer, exceptional in their own right, appeared to follow their own path, often pulling in different directions. The amount of energy and time lost to internal strife was significant, and the expected outcomes? They remained just that – expected. This experience was a clear lesson that the success of a team isn't merely based on individual talent; it's about harmony, alignment, and collaboration. With today’s workplaces being more diverse, widespread, digitized, and ever-changing, achieving this is certainly challenging. So, in my quest to understand the nuances of high-performing teams, I reached out to my friend Hari Haralambiev. As a coach of dev teams who care about people, Hari has worked with numerous tech organizations, guiding them to unlock their teams’ potential. Here are his top 5 tips for developing high performing teams: 1. Be Inclusive ↳Put a structure in place so that the most vocal people don’t suffocate the silent voices. Great teams make sure minority views are heard and taken into account. They make it safe for people to speak up. 2. Leverage Conflict ↳Disagreements should be encouraged and how you handle them is what makes your team poor or great. Great teams mine for conflict - they cherish disagreements. To handle disagreements properly make sure to separate discussion from decision. 3. Decision Making Process ↳Have a clear team decision-making method to resolve conflicts quickly. The most important decision a team should make is how to make decisions. Don’t look for 100% agreement. Look for 100% commitment. 4. Care and Connect ↳This is by far the most important tip. Teams who are oriented only on results are not high-performing. You need to create psychological safety and build trust between people. To do that - focus on actually knowing the other people and to make it safe to be vulnerable in front of others. Say these 4 phrases more often: ‘I don’t know’, ‘I made a mistake’, ‘I’m sorry’, ‘I need help’. 5. Reward experimentation and risk taking ↳No solution is 100% certain. People should feel safe to take risks and make mistakes. Reward smart failure. Over-communicate that it’s better to take action and take accountability than play it safe. Remember, 'team' isn't just a noun—it's a verb. It requires ongoing effort and commitment to work at it, refine it, and nurture it. Do give Hari a follow and join over 6K+ professionals who receive his leadership comics in his newsletter A Leader’s Tale.

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.

I keep hearing "session replays just didn't make it in the priority list." One ritual to make time? Andrew Capland suggests weekly sessions: Andrew was a 2x head of growth. His favorite ritual? — A weekly team meeting called "Fullstory Fridays." Every Friday, the team would come together live with the goal of gaining insights from user experience. An informal setting where there was no pressure to do something just for the sake of it. They would pull out 20 different user interaction sessions, and each team member focused on their area: → Engineers would spot bugs, take notes, and sometimes fix them on the fly... → Designers would see people rage-clicking and sketch ideas to improve the experience... → And beyond this, they often found users translating their app into different languages... (something they hadn’t even considered.) Doing this helped them: → Better understand problems without guessing → Understand their users better → Come up with fresh ideas — I think doing this in an informal session with a team of experts is so powerful: A. It doesn’t feel like a chore Every PM dreads sitting for hours watching users interact with their product. But when you do it together in an informal setting, it’s not boring anymore, especially if you’re having fun along the way. B. Cross-functional alignment Engineers, PMs, and designers gain firsthand exposure to real user problems. And develop a shared understanding of what users are "silently" asking for. C. Better prioritization The team rallies around what truly matters to users.

Tired of arguing with your coworkers during #codereviews? Why not start a Team Working Agreement with your #softwaredevelopment team? A team working agreement sets the ground rules for your team and how they review code. You should discuss and document key things like: 1. How fast should reviews happen? Agree on an appropriate turnaround times for reviews and state that in your TWA. Also describe what can be done if someone isn't adhering to the turnaround times. 2. What's our limit on PRs? Define PR size limits: whether that's roughly the amount of lines changed or a maximum on the number of files to be reviewed, a guideline can help keep a #pullrequest small. And remember: Small PRs mean faster, more efficient reviews. 3. Are you allowed to self-approve? Handle self-approvals: Can authors approve their own PRs? If so, when and under what circumstances? Are you making sure this won't be abused? 4. Determine whether you'll allow nitpicks. While I strongly suggest taking nitpicks out of the review (because most are subjective or can be fixed before the review), state if you'll be allowed to bring up nitpicks in a review at all. If you do, be sure to use the "nitpick: or nit:" prefix and explain what should be considered a nitpick.  5. What's allowed to block a review? Clarify what can block a #PR from being approved (and ultimately, merged into prod): Security issues? Missing tests? Missing documentation? Readability? Something else? The clearer your team is about blocking vs non-blocking issues, the fewer your debates will be during the #codereview. By drafting your own Team Working Agreement, you can start to make reviews less painful and more productive. And remember, you can always revisit this document and make changes as your team evolves. Just make sure you discuss and agree to the changes as a team! Get a TWA template in my book: https://lnkd.in/dKwGg667 And follow (theLGTMBook to be a better #codereviewer! https://lnkd.in/gJaDvkEu