Software Development Lifecycle In Engineering

Reflecting on Agile Development with DevOps 2.0: A Flexible CI/CD Flow Last year, I shared a CI/CD process flow for Agile Development with DevOps 2.0, and it’s been amazing to see how much it resonated with the community! This framework isn’t about specific tools—it’s about creating a seamless, collaborative process that supports quality and agility at every step. ✅ 𝗣𝗹𝗮𝗻: Building a Strong Foundation with Clear Alignment The journey begins with planning—whether it's user stories, tasks, or broader product goals. Tools like JIRA or Asana (or any project management platform) help capture requirements and align the team with the Product Owner’s vision. This early alignment is essential to avoid misunderstandings and establish a shared understanding of success. Key Insight: Planning thoroughly and involving stakeholders from the start leads to a smoother process. When everyone’s on the same page, the entire pipeline benefits. ✅ 𝗖𝗼𝗱𝗲: Collaborative Development and Real-Time Feedback In the coding phase, developers work together, often pushing code to a version control platform like GitHub or Bitbucket and communicating via real-time collaboration tools like Slack or Teams. Open communication and continuous feedback help catch issues early and keep the team in sync. Key Insight: Real-time feedback is crucial for speed and quality. Regardless of the tools, creating a culture of continuous collaboration makes all the difference. ✅ 𝗕𝘂𝗶𝗹𝗱: Automating Quality and Security Checks As code is committed, it’s essential to automate quality and security checks. Tools like Jenkins, CircleCI, or any CI/CD platform can trigger builds and run automated tests, ensuring that quality checks are consistent and fast. This step helps prevent issues from creeping into production. Key Insight: Automated checks for quality and security are invaluable. Integrating these checks into the build process improves confidence in every deployment. ✅ 𝗧𝗲𝘀𝘁: Structured, Multi-Environment Testing Testing is layered across environments—whether it’s regression, unit, or user acceptance testing (UAT). Using frameworks like Selenium for automated testing or dedicated QA/UAT environments enables rigorous validation before production. Key Insight: Testing across environments is a safeguard for quality. Structured testing helps ensure that code is reliable and ready for release. ✅ 𝗥𝗲𝗹𝗲𝗮𝘀𝗲: Scalable, Reliable Deployments with Infrastructure as Code (IAC) Finally, using Infrastructure as Code (IAC) principles with tools like Terraform, Ansible, or other IAC solutions, deployments are made repeatable and scalable. IAC empowers teams to manage infrastructure more efficiently, ensuring consistent and controlled releases. Thank you to everyone who has engaged with this diagram and shared your insights! I’d love to hear how others approach CI/CD. Are there any tools or strategies that have worked well for you?

I’m a product manager with nearly 20 years of experience in the software industry. If I could sit down with a Jr. Product Manager today, here are 11 pieces of advice I’d share - lessons I’ve learned along the way: 1- If your product targets a small user group, focus on delivering core value quickly and keep the roadmap simple. But if you aim for millions of users, you need scalable infrastructure, solid user segmentation, and robust analytics. 2- If you’re the only PM shaping the product, lightweight processes and direct communication work. But with multiple teams involved, invest in clear roadmaps, regular syncs, and strong prioritization frameworks. 3- If a feature failure impacts only a small user segment, a quick fix and transparent communication is enough. But if a bug breaks critical workflows, you must have incident response plans, clear escalation paths, and backup solutions. 4- If you’re gathering user feedback informally, simple surveys or chats might do. But if you’re scaling, invest in structured research, usability testing, and customer journey mapping to truly understand your users. 5- If you can rely on gut feeling for early decisions, that’s okay initially. But as the product grows, leverage data analytics, A/B testing, and customer metrics to guide your roadmap. 6- If your data needs are small, simple dashboards and reports work. But when handling large datasets, build scalable analytics, automate data pipelines, and use data warehouses effectively. 7- If you’re working solo, inconsistent documentation might not slow you much. But in a larger team, clear user stories, acceptance criteria, and consistent terminology avoid confusion and speed up development. 8- If your support volume is low, handling customer issues via email or chat may be enough. But when the product grows, set up help desks, ticketing systems, and real-time customer feedback loops. 9- If deadlines are tight, deliver MVP features that work. But if the product is strategic, focus on maintainability, testing, and designing for future growth. 10- If you’re collaborating with one or two stakeholders, informal check-ins might suffice. But with multiple teams, establish regular planning sessions, shared documentation, and clear decision-making processes. 11- If your product is in early stages, prioritize speed and learning. But once it matures, clean up tech debt, optimize processes, and rethink features carefully to avoid “maintenance hell.” People often think product management is just about building features. But really, it’s about: – Knowing when to say no – Being ready to pivot or remove features – Making tradeoffs with imperfect data The best product managers don’t just move fast. They build the right foundations that allow their teams to move fast safely.

Navigating Team Conflicts In team dynamics, some level of conflict is inevitable—even healthy. However, understanding the nature of the conflict can help leaders manage and resolve it more effectively. Here are four common conflict patterns and strategies for handling them: 1. The Solo Dissenter This conflict arises when one individual disagrees with the rest of the team. Whether due to personal differences or a challenge to the status quo, isolating or scapegoating this person is counterproductive. Instead, leaders should engage in one-on-one conversations to better understand their perspective and address any underlying concerns. Open communication can transform a dissenter into a valuable source of alternative viewpoints and broader system awareness. 2. The Boxing Match This frequent form of conflict involves a disagreement between two team members. If the issue stems from a personal relationship, external coaching may be helpful. However, if it’s task-related, the disagreement may benefit the team by introducing diverse ideas—provided the discussion remains civil. Leaders should avoid intervening prematurely, as genuine task-based disagreements often lead to more innovative solutions. 3. Warring Factions When two subgroups within the team oppose each other, an "us versus them" mentality can develop. This type of conflict is more complex, and solutions like voting or majority rule rarely resolve the issue. Leaders should introduce new options or third-way alternatives, encouraging both sides to broaden their thinking and find a compromise that addresses the core needs of both groups. 4. The Blame Game This challenging conflict involves the entire team, often triggered by poor performance. Assigning blame worsens the situation and creates more division. A more effective approach is to refocus the team on collective goals and explore strategies for improvement. Shifting the conversation from blame to team purpose and collective problem-solving can unite the group around a shared vision. By recognizing these conflict patterns and applying the right strategies, leaders can guide their teams through disagreements, fostering a more cohesive and productive environment.

"Agentic Code Review" - The hard part of engineering isn't writing code anymore. Coding agents are extraordinarily good now and getting better fast. But the hard part of engineering has moved from writing code to deciding whether to trust it. Code review is the big bottleneck. My latest free deep-dive: https://lnkd.in/gSZqtKDP ✍ AI pushes raw output up by about 4x, but real productivity gains sit closer to 12%. The gap between those numbers is review work. Because we poured machine-speed output into a system built for human-speed work, the friction has moved downstream: - PRs merged with zero human review are up 31.3% - Median review duration is up 441.5% - The per-developer defect rate has jumped from 9% to 54% How you solve this depends entirely on your blast radius. A solo developer vibe-coding a side project and a team keeping a ten-year-old enterprise system alive share almost no constraints. To adapt, the rules of code review have to change: Tier by risk, not author: Spend scarce human attention only where being wrong is costly. A config change gets a linter; a payments path gets the full stack of tests, multiple AI reviewers, and human ownership. Embrace heterogeneous AI review: CodeRabbit, Greptile, Seer, and others all catch different classes of bugs. Run at least two with deliberately different characters. Keep humans on the loop: The volume ended the era of a human reading every single line. Instead, humans must own the accountability, the high-stakes gates, and the judgment of whether the change was the right thing to build in the first place. We made writing cheap, but understanding a system well enough to stand behind it remains the most durable and interesting skill in software. I mapped out exactly where the work has shifted in my latest write-up and hope you find it helpful. #ai #programming #softwareengineering

People often ask how we manage complex projects as a team of 100 people in 35 countries, and since I'm currently revamping our documentation on this subject, that info is top of mind. Here's 29 pages of content condensed into 1 LI post for a sneak peek into our DO (Doist Objectives) System 👀 It starts with our annual roadmap, which the leadership team builds in Q4 of the prior year. To execute that plan, we organize our work into four areas of priority (Strategic Priorities, aka SPs), each running multiple initiatives simultaneously in quarterly "cycles", and overseen by a Directly Responsible Doister (DRD): • Brand (DRD: CMO): Marketing campaigns, brand evolution, growth initiatives • Product (DRD: Head of Product): New features, user experience improvements, product strategy • Engineering (DRD: CTO): Platform stability, performance optimization, technical infrastructure • Doist (DRD: 🙋🏻♂️): Internal tools, company operations, team effectiveness Planning kicks off four weeks before each quarter when the CXOs provide the DRDs with general guidance and goals. We respond by proposing general plans for DOs (Doist Objectives; projects/initiatives) in line with our annual roadmap. Two weeks before the new quarter begins, the DOs are agreed upon and the team Heads assign team members to cross-functional "Squads" as "Squad Leaders" and "Squad Members". **See photos below to illustrate the squad infrastructure. Each SP typically runs 2-5 major DOs per quarter, meaning we're executing 12-16 significant projects at any time. The quarter begins with a two-week "Foundation Phase", where squads: • Deep dive into the challenges and opportunities their squad faces • Conduct user research • Create comprehensive specs detailing their proposed solutions • Align on execution approach • This phase ensures we have the space to avoid diving too deep into the upcoming cycle while working on the current cycle From there, squads maintain momentum for the following 10 weeks in the "Execution Phase" through established rituals: • Weekly "snippets" in Twist for progress updates and transparency (our version of an async standup meeting) • Bi-weekly recorded demos to showcase work in-depth • Monthly retrospectives on squad health for continuous improvement • Monthly companywide updates on each strategic priority's DOs • Monthly strategic reviews/adjustments by the leadership team • Expectation = each squad should "ship" something weekly Of course, we manage most of this using Twist for communication and Todoist for project management, but more so than the tools, this system works for us because we emphasize clear ownership/autonomy, transparent communication, and just enough processes to stay coordinated without slowing the team down. That was a lot to digest, but I hope it's helpful. Let me know if I can expand on anything or answer any other questions 👇

Most of us review code in the wrong order. We spot a missing test or a style inconsistency before even asking whether the code is correct. We should think about it differently. The first question should always be: Does this code do what it is supposed to do? If the answer is no, nothing else matters. Style, structure, tests - all secondary to correctness. Once you are confident it is correct, ask if it is clear. Can someone else (or you, six months from now) understand what is happening and why? Clarity in code helps ensure it does not become a liability. Then check whether it matches the style and conventions, because inconsistencies add cognitive load for everyone who reads the codebase afterward. After that, look for duplication. Is this solving a problem that is already solved somewhere else? Could this be a shared utility? Finally, ask whether it is well tested. Not just "are there tests" (non-sensical ones), but do the tests actually cover the meaningful cases? Correctness. Clarity. Style. Deduplication. Tests. In that order, every time. Hope this helps.

Teams will increasingly include both humans and AI agents. We need to learn how best to configure them. A new Stanford University paper "ChatCollab: Exploring Collaboration Between Humans and AI Agents in Software Teams" reveals a range of useful insights. A few highlights: 💡 Human-AI Role Differentiation Fosters Collaboration. Assigning distinct roles to AI agents and humans in teams, such as CEO, Product Manager, and Developer, mirrors traditional team dynamics. This structure helps define responsibilities, ensures alignment with workflows, and allows humans to seamlessly integrate by adopting any role. This fosters a peer-like collaboration environment where humans can both guide and learn from AI agents. 🎯 Prompts Shape Team Interaction Styles. The configuration of AI agent prompts significantly influences collaboration dynamics. For example, emphasizing "asking for opinions" in prompts increased such interactions by 600%. This demonstrates that thoughtfully designed role-specific and behavioral prompts can fine-tune team dynamics, enabling targeted improvements in communication and decision-making efficiency. 🔄 Iterative Feedback Mechanisms Improve Team Performance. Human team members in roles such as clients or supervisors can provide real-time feedback to AI agents. This iterative process ensures agents refine their output, ask pertinent questions, and follow expected workflows. Such interaction not only improves project outcomes but also builds trust and adaptability in mixed teams. 🌟 Autonomy Balances Initiative and Dependence. ChatCollab’s AI agents exhibit autonomy by independently deciding when to act or wait based on their roles. For example, developers wait for PRDs before coding, avoiding redundant work. Ensuring that agents understand role-specific dependencies and workflows optimizes productivity while maintaining alignment with human expectations. 📊 Tailored Role Assignments Enhance Human Learning. Humans in teams can act as coaches, mentors, or peers to AI agents. This dynamic enables human participants to refine leadership and communication skills, while AI agents serve as practice partners or mentees. Configuring teams to simulate these dynamics provides dual benefits: skill development for humans and improved agent outputs through feedback. 🔍 Measurable Dynamics Enable Continuous Improvement. Collaboration analysis using frameworks like Bales’ Interaction Process reveals actionable patterns in human-AI interactions. For example, tracking increases in opinion-sharing and other key metrics allows iterative configuration and optimization of combined teams. 💬 Transparent Communication Channels Empower Humans. Using shared platforms like Slack for all human and AI interactions ensures transparency and inclusivity. Humans can easily observe agent reasoning and intervene when necessary, while agents remain responsive to human queries. Link to paper in comments.

The shift to remote work has become our reality, and leading distributed development teams effectively requires a new set of strategies. Here's my advice on managing remote development teams: Prioritize Human Connection: •Regular visits and social interactions between team members in different locations are crucial. These face-to-face interactions foster stronger relationships and understanding, making communication smoother. •Building trust and breaking down "tribal" barriers is essential for effective collaboration. When teams feel connected, they are more likely to support each other and work towards shared goals. Optimize Team Structure: •Avoid geographically splitting teams by function. Instead, organize teams around features or projects, with all necessary roles represented at each location. This reduces communication barriers and fosters cross-functional collaboration. •If functional splits are unavoidable, empower remote teams to make decisions and take ownership, rather than resorting to "programming by remote control." Clear goals and guidance are essential, but micromanagement stifles creativity and innovation. Embrace Asynchronous Communication: •Supplement live meetings with asynchronous written communication tools like chat platforms. This helps overcome language barriers and allows team members to participate at their own pace. •Clear documentation and well-maintained systems like version control, CI/CD, and wikis are critical for smooth collaboration. Invest in Effective Tools and Infrastructure: •Don't skimp on technology. Equipping remote teams with the right tools and infrastructure ensures they can work efficiently and productively.4 •Prioritize robust communication channels, efficient CI/CD pipelines, and effective knowledge-sharing platforms. Remote work may present unique challenges, but with the right approach, we can unlock its potential and build thriving, collaborative development teams.

𝟭. 𝗕𝘂𝘀𝗶𝗻𝗲𝘀𝘀 𝗥𝗲𝗾𝘂𝗶𝗿𝗲𝗺𝗲𝗻𝘁𝘀 𝗗𝗼𝗰𝘂𝗺𝗲𝗻𝘁 (𝗕𝗥𝗗): A BRD captures high-level business needs and objectives from a stakeholder’s perspective. It focuses on why a project is being undertaken and what value it brings to the business. 𝗞𝗲𝘆 𝗘𝗹𝗲𝗺𝗲𝗻𝘁𝘀: • Business objectives • Stakeholder needs • High-level business requirements • Scope of the project • Business rules • Assumptions and constraints 𝟮. 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝗮𝗹 𝗥𝗲𝗾𝘂𝗶𝗿𝗲𝗺𝗲𝗻𝘁𝘀 𝗗𝗼𝗰𝘂𝗺𝗲𝗻𝘁 (𝗙𝗥𝗗): An FRD translates high-level business needs into detailed functional requirements that describe how a system should behave. It focuses on system interactions, workflows, and features that will fulfill business requirements. 𝗞𝗲𝘆 𝗘𝗹𝗲𝗺𝗲𝗻𝘁𝘀: • Functional requirements (detailed descriptions of features) • System workflows • Use cases and user stories • UI/UX requirements (screens, wireframes) • Data flow diagrams 𝟯. 𝗦𝗼𝗳𝘁𝘄𝗮𝗿𝗲 𝗥𝗲𝗾𝘂𝗶𝗿𝗲𝗺𝗲𝗻𝘁𝘀 𝗦𝗽𝗲𝗰𝗶𝗳𝗶𝗰𝗮𝘁𝗶𝗼𝗻 (𝗦𝗥𝗦): An SRS is a comprehensive document that includes both functional and non-functional requirements, providing a complete specification of how the software should work. It is often used by developers and testers for system implementation. 𝗞𝗲𝘆 𝗘𝗹𝗲𝗺𝗲𝗻𝘁𝘀: • Functional requirements (features & capabilities) • Non-functional requirements (performance, security, scalability) • System architecture & design constraints • Data models • Interfaces (API, external system interactions) While the 𝗕𝗥𝗗, 𝗙𝗥𝗗, and 𝗦𝗥𝗦 serve different purposes, they all contribute to 𝗰𝗹𝗲𝗮𝗿 𝗮𝗻𝗱 𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲𝗱 𝗿𝗲𝗾𝘂𝗶𝗿𝗲𝗺𝗲𝗻𝘁𝘀. In 𝗔𝗴𝗶𝗹𝗲 𝗲𝗻𝘃𝗶𝗿𝗼𝗻𝗺𝗲𝗻𝘁𝘀, these documents may be replaced with 𝗣𝗿𝗼𝗱𝘂𝗰𝘁 𝗕𝗮𝗰𝗸𝗹𝗼𝗴𝘀, 𝗨𝘀𝗲𝗿 𝗦𝘁𝗼𝗿𝗶𝗲𝘀, 𝗮𝗻𝗱 𝗘𝗽𝗶𝗰𝘀, but in 𝗪𝗮𝘁𝗲𝗿𝗳𝗮𝗹𝗹 𝗼𝗿 𝗵𝘆𝗯𝗿𝗶𝗱 𝗺𝗼𝗱𝗲𝗹𝘀, they are still widely used. Which of these documents do you use in your projects? Let’s discuss in the comments! 👇 #BusinessAnalysis #IIBA #BRD #FRD #SRS #RequirementsEngineering #SoftwareDevelopment

❌ Behavior-Driven Development (BDD) is NOT Cucumber ❌ There's a common misconception that BDD is just another name for tools like Cucumber. While Cucumber is a popular tool used in BDD, it's important to recognize that BDD is a philosophy and a mindset rather than just a specific tool or framework. ✅ BDD is NOT Cucumber: At its core, BDD is about fostering collaboration, enhancing communication, and ensuring that software development efforts are aligned with the needs and expectations of stakeholders, particularly end users. So, what exactly is BDD if it's not just about Cucumber? 📌 BDD is a collaborative approach: BDD emphasizes collaboration among all stakeholders. This includes developers, testers, business analysts, product owners, and end users. By bringing everyone together to discuss and define the behaviour of the system in a common language, BDD ensures that everyone is on the same page from the outset. 📌 BDD focuses on behaviour: At its heart, BDD is all about defining the behaviour of the software from the perspective of its users. This means describing how the system should behave in various scenarios or situations. For instance, imagine a banking application where a user deposits money into their account. In BDD, this scenario might be expressed as "Given the user has logged into their account when they deposit 100, then the account balance should increase by 100." This concrete example clarifies the expected behaviour of the application. 📌 BDD uses executable specifications: One of the key principles of BDD is the creation of executable specifications. These are written in a human-readable format using Given-When-Then syntax, which describes the initial context, the action being taken, and the expected outcome. These specifications serve as living documentation that can be understood by both technical and non-technical stakeholders. 📌 BDD is about continuous feedback: Another aspect of BDD is its emphasis on continuous feedback loops. By involving stakeholders throughout the development process, teams can gather feedback early and often, making it easier to course-correct and adapt to changing requirements. This iterative approach helps in delivering software that truly meets user needs and expectations. 📌 BDD promotes shared understanding: BDD encourages teams to use a common language, a language that is understood by everyone involved in the project. This shared understanding fosters better communication and reduces the chances of misunderstandings or misinterpretations. It ensures that everyone is speaking the same language when discussing requirements, which leads to more accurate implementation and fewer errors. 📌 BDD enhances Test-Driven Development (TDD): While BDD and TDD are distinct methodologies, they complement each other well. BDD provides a higher-level perspective, focusing on the behaviour of the system, while TDD drills down into the implementation details by writing tests before writing code.