Software Development Lifecycle In Engineering

“Loop engineering” is a hot buzzphrase after mentions of it by Boris Cherny (Claude Code’s creator) and Peter Steinberger (OpenClaw's creator) went viral on social media. Loops are now a key part of how we get AI agents to iterate at length to build software. In this letter, I’d like to share my 3 key loops, shown in the image below, for building 0-to-1 products. These loops guide not just how I build software, but also how I decide what software to build. Agentic coding loop: Given a product specification and optionally a set of evals (that is, a dataset against which to measure performance), we can have an AI agent write code, test its work, and keep iterating until the code is bug-free and meets its specification. This idea of closing the loop took off around the end of last year, and it has been a game changer in enabling coding agents to work longer productively without human intervention. For example, over the weekend, I was building an app for my daughter to practice typing, and my coding agent could easily work for around an hour, using a web browser to check what it had built multiple times before getting back to me, without needing my intervention. The engineering loop executes quickly. Every few minutes, the coding agent might build and test a new version of the software. I hear frequently from developers who are finding new ways to engineer more effective engineering loops. This is an active area of invention! Developer feedback loop: In this loop, a developer examines the current product and steers the coding agent to improve it. Last year, a lot of developers (including me) were acting as the QA (quality assurance) function for our coding agents, manually finding bugs and then asking the agent to fix them. But with coding agents much more able to test their own code, the amount of time we need to spend on this function has decreased significantly. This allows us to make higher-level product decisions, such as what key features to offer, where the UI needs improvement, and so on. The developer-feedback loop operates over time intervals between tens of minutes and hours — that's how frequently a developer might review a product and give feedback. In the case of the typing app, I changed my mind a few times about the visual design, what cat costumes she can unlock as she learns (she loves cats), and the user flow for a grown-up to log in and steer the child's learning experience. When a developer has a clear vision for what to build, it is still a lot of work to translate that vision into a specification for a coding agent to implement. Further, after the developer has seen an implementation, they might update (or perhaps clarify) the spec to steer it toward what they want. If you find that the system repeatedly runs into certain problems, building a set of evals for the agent becomes useful. [Truncated for length. Full text: https://lnkd.in/gKDQ6H9s]

Software development is quietly undergoing its biggest shift in decades. Not because of new frameworks. Not because of faster cloud. But because agents are entering the SDLC. Traditional development follows a slow, sequential loop: requirements → design → coding → testing → reviews → deployment → monitoring → feedback. Each step depends on human handoffs, manual fixes, delayed feedback, and long iteration cycles—often stretching from weeks to months. Agentic coding changes this entirely. Instead of humans writing everything line-by-line, developers express intent. Agents understand requirements, implement features, generate tests and documentation, deploy changes, monitor production, and even propose fixes. The lifecycle compresses from weeks and months into hours or days. Here’s what actually changes: • Sequential handoffs become continuous agent-driven flows • Humans shift from coding to guiding and reviewing • Documentation is generated inline, not after delivery • Testing happens automatically alongside implementation • Incidents trigger agent-assisted remediation • Monitoring feeds directly back into learning loops • Iteration becomes constant, not episodic In the Agentic SDLC: You describe outcomes. Agents execute workflows. Humans validate critical decisions. Systems learn continuously. The result isn’t just faster delivery. It’s a fundamentally different operating model for engineering—where feedback is immediate, fixes are automated, and improvement never stops. This is how software teams move from manual development pipelines to self-improving delivery systems.

Your software development organization is slow?  Business and customers are complaining? There is an easy fix: WIP limits. Most organizations face a common problem: they are slow. Usually because they are trying to do everything at once. Development teams juggle multiple projects, thinking this maximizes productivity. Traditional fixes? - Throw more resources at it. - Add developers. - Buy new tools. - Reorganize teams. All expensive, all time-consuming, all missing the real issue. The solution is surprisingly simple: Stop starting and start finishing. WIP (Work in Progress) limits force teams to complete current tasks before taking on new ones. It's like traffic flow - cars move faster on an uncrowded highway than in bumper-to-bumper congestion. Here's a real example: Three 6-week projects. With multitasking, Project A finishes in week 16, B in week 17, C in week 18. With WIP limits? A done in week 6, B in week 12, C still in week 18. Same total time, but value delivered 10 weeks earlier. Want to implement WIP limits? 1. Start with one pilot team 2. Set initial WIP limits at 70-80% of current workload 3. Reduce by 10-20% every few weeks 4. Watch delivery times drop while throughput stays steady 5. Visualize the effects! Stop starting new work. Start finishing what's in progress and become as twice as fast. What's your experience with WIP limits? Share your thoughts in the comments.

As a client project manager, I consistently found that offshore software development teams from major providers like Infosys, Accenture, IBM, and others delivered software that failed 1/3rd of our UAT tests after the provider's independent dedicated QA teams passed it. And when we got a fix back, it failed at the same rate, meaning some features cycled through Dev/QA/UAT ten times before they worked. I got to know some of the onshore technical leaders from these companies well enough for them to tell me confidentially that we were getting such poor quality because the offshore teams were full of junior developers who didn't know what they were doing and didn't use any modern software engineering practices like Test Driven Development. And their dedicated QA teams couldn't prevent these quality issues because they were full of junior testers who didn't know what they were doing, didn't automate tests and were ordered to test and pass everything quickly to avoid falling behind schedule. So, poor quality development and QA practices were built into the system development process, and independent QA teams didn't fix it. Independent dedicated QA teams are an outdated and costly approach to quality. It's like a car factory that consistently produces defect-ridden vehicles only to disassemble and fix them later. Instead of testing and fixing features at the end, we should build quality into the process from the start. Modern engineering teams do this by working in cross-functional teams. Teams that use test-driven development approaches to define testable requirements and continuously review, test, and integrate their work. This allows them to catch and address issues early, resulting in faster, more efficient, and higher-quality development. In modern engineering teams, QA specialists are quality champions. Their expertise strengthens the team’s ability to build robust systems, ensuring quality is integral to how the product is built from the outset. The old model, where testing is done after development, belongs in the past. Today, quality is everyone’s responsibility—not through role dilution but through shared accountability, collaboration, and modern engineering practices.

𝟭. 𝗕𝘂𝘀𝗶𝗻𝗲𝘀𝘀 𝗥𝗲𝗾𝘂𝗶𝗿𝗲𝗺𝗲𝗻𝘁𝘀 𝗗𝗼𝗰𝘂𝗺𝗲𝗻𝘁 (𝗕𝗥𝗗): 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

A sluggish API isn't just a technical hiccup – it's the difference between retaining and losing users to competitors. Let me share some battle-tested strategies that have helped many  achieve 10x performance improvements: 1. 𝗜𝗻𝘁𝗲𝗹𝗹𝗶𝗴𝗲𝗻𝘁 𝗖𝗮𝗰𝗵𝗶𝗻𝗴 𝗦𝘁𝗿𝗮𝘁𝗲𝗴𝘆 Not just any caching – but strategic implementation. Think Redis or Memcached for frequently accessed data. The key is identifying what to cache and for how long. We've seen response times drop from seconds to milliseconds by implementing smart cache invalidation patterns and cache-aside strategies. 2. 𝗦𝗺𝗮𝗿𝘁 𝗣𝗮𝗴𝗶𝗻𝗮𝘁𝗶𝗼𝗻 𝗜𝗺𝗽𝗹𝗲𝗺𝗲𝗻𝘁𝗮𝘁𝗶𝗼𝗻 Large datasets need careful handling. Whether you're using cursor-based or offset pagination, the secret lies in optimizing page sizes and implementing infinite scroll efficiently. Pro tip: Always include total count and metadata in your pagination response for better frontend handling. 3. 𝗝𝗦𝗢𝗡 𝗦𝗲𝗿𝗶𝗮𝗹𝗶𝘇𝗮𝘁𝗶𝗼𝗻 𝗢𝗽𝘁𝗶𝗺𝗶𝘇𝗮𝘁𝗶𝗼𝗻 This is often overlooked, but crucial. Using efficient serializers (like MessagePack or Protocol Buffers as alternatives), removing unnecessary fields, and implementing partial response patterns can significantly reduce payload size. I've seen API response sizes shrink by 60% through careful serialization optimization. 4. 𝗧𝗵𝗲 𝗡+𝟭 𝗤𝘂𝗲𝗿𝘆 𝗞𝗶𝗹𝗹𝗲𝗿 This is the silent performance killer in many APIs. Using eager loading, implementing GraphQL for flexible data fetching, or utilizing batch loading techniques (like DataLoader pattern) can transform your API's database interaction patterns. 5. 𝗖𝗼𝗺𝗽𝗿𝗲𝘀𝘀𝗶𝗼𝗻 𝗧𝗲𝗰𝗵𝗻𝗶𝗾𝘂𝗲𝘀 GZIP or Brotli compression isn't just about smaller payloads – it's about finding the right balance between CPU usage and transfer size. Modern compression algorithms can reduce payload size by up to 70% with minimal CPU overhead. 6. 𝗖𝗼𝗻𝗻𝗲𝗰𝘁𝗶𝗼𝗻 𝗣𝗼𝗼𝗹 A well-configured connection pool is your API's best friend. Whether it's database connections or HTTP clients, maintaining an optimal pool size based on your infrastructure capabilities can prevent connection bottlenecks and reduce latency spikes. 7. 𝗜𝗻𝘁𝗲𝗹𝗹𝗶𝗴𝗲𝗻𝘁 𝗟𝗼𝗮𝗱 𝗗𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗶𝗼𝗻 Beyond simple round-robin – implement adaptive load balancing that considers server health, current load, and geographical proximity. Tools like Kubernetes horizontal pod autoscaling can help automatically adjust resources based on real-time demand. In my experience, implementing these techniques reduces average response times from 800ms to under 100ms and helps handle 10x more traffic with the same infrastructure. Which of these techniques made the most significant impact on your API optimization journey?

Have you ever spent endless hours on a project just to end up realising that a more straightforward method would have been more effective? This common mistake, referred to as over-engineering, can cause needless complexity and inefficiency when developing new products. Understanding Over-engineering > Over-engineering happens when a solution gets more difficult than it needs to be, usually by adding features or functionalities that do not directly meet the needs of customers. > This can lead to higher costs, longer development cycles, and less user-friendly products. Real-World Example: The Juicero The Juicero, a high-tech juicing machine, was released in 2016. It cost $700 and was designed to squeeze proprietary juice packets with considerable force. Later on, though, it was found that the costly machine was not essential because the same juice bags could be squeezed by hand. The company was eventually shut down as a result of the public outcry following this disclosure. My Own Story: The Overly Complex Website I was in a team early in my career that was assigned with creating a company website. We included the newest interactive elements and design trends in an effort to wow. Feedback received after the launch, however, indicated that visitors found the website overwhelming and challenging to use. In our pursuit of innovation, we had failed to realise the website's main purpose, which is to provide easily comprehensible information. I learnt the importance of simplicity and user-centred design from this experience. Useful Tips to Prevent Over-Engineering 1. Pay attention to the essential needs: Focus on key features that meet user needs and clearly explain the issue you're trying to solve. Don't include features that aren't directly useful. 2. Adopt Incremental Development: Begin with an MVP that satisfies the fundamental specifications. By using this method, you may get user input and decide on new features with knowledge. 3. Put Simplicity First: Use the KISS philosophy, which stands for "Keep It Simple, Stupid." Simpler designs are frequently easier to use and more efficient. 4. Verify Assumptions: Talk to users to learn about their wants and needs. This guarantees that the things you create will actually be useful to them. 5. Promote Open Communication: Create an environment where team members are at ease sharing thoughts and possible difficulties. Over-engineering tendencies can be recognised and avoided with the support of this collaborative environment. Have any of your initiatives involved over-engineering? How did you respond to it? Post your thoughts and experiences in the comments section below!

Red Flags Every QA Professional Should Watch For In the dynamic world of software development, Quality Assurance (QA) isn’t just about detecting bugs—it’s about ensuring excellence in the user experience, system performance, and product stability. But what happens when things go off track? Recognizing the red flags early can save teams from major pitfalls. Here are some critical red flags every QA expert must watch out for: 1. Undefined Requirements If user stories or business requirements are ambiguous or missing, your testing foundation is weak. This leads to misaligned expectations and inconsistent test coverage. Red Flag: “We’ll finalize the requirements later.” 2. Last-Minute QA Involvement QA must be involved from the requirement gathering phase. If testing is seen only as a final step, it usually results in rushed testing and missed defects. Red Flag: “We’ll add QA just before the release.” 3. No Time for Regression Testing Skipping regression testing or performing it under tight deadlines increases the risk of breaking existing features—a major cause of production defects. Red Flag: “Let’s skip regression for now.” 4. Lack of Test Environments An unstable or shared test environment often leads to inconsistent test results, impacting productivity and delaying defect validation. Red Flag: “The environment is being used by another team.” 5. Poor Communication Between Teams If developers, product managers, and QA work in silos, it leads to misunderstandings and incomplete testing. Red Flag: “I assumed that was already tested.” 6. Minimal or No Automation In 2025, relying solely on manual testing for repetitive tasks is a red flag. Test automation is essential for faster feedback cycles and scalable testing. Red Flag: “We don’t have time to automate this.” 7. No Defect Triage Process Without regular triage meetings, defects are ignored, poorly prioritized, or closed without resolution—damaging product quality. Red Flag: “We’ll review bugs before release—hopefully.” 8. Overreliance on Happy Path Testing If the focus is only on expected scenarios, edge cases and failure conditions are neglected, leading to critical bugs post-launch. Red Flag: “We only tested the main workflow.” Final Thoughts: A great QA professional doesn’t just find bugs—they prevent them by identifying process-level gaps early. If you’re noticing these red flags, raise your voice, realign with the team, and advocate for quality-first development. Let’s champion quality—every sprint, every release. #QualityAssurance #SoftwareTesting #QA #QATips #BugHunting #TestAutomation #AgileTesting #DevOps #ManualTesting #QALife #RedFlagsInQA #TestProcess #TechLeadership #SudhanshuYadav #QualityExpert

Most companies suck at launching products. They’re like Alice in Wonderland — chasing shiny objects and getting lost along the way. Here’s the 11-step process we perfected after 25 years of product launches (in a collaboration with Jason Oakley): 1. Competitive Research The key to great strategy is to look externally. Take notes on competitor's features and how they grow. Build a database so you can counter-position appropriately. 2. Segmentation A launch aimed at “everyone” will miss everyone. Instead, build a laser-focused Ideal Customer Profile (ICP). Follow this chain of thought: What are they craving? → What frustrates them daily? → What job are they trying to accomplish? 3. Pricing & Packaging Even the smallest feature can have a ripple effect on your pricing and packaging. Don’t wait until launch week to figure this out. Before launching, assess things like: Will this be a paid feature or free? Who will get access? What’s the plan for feature gating? 4. Positioning Now it’s time to craft a message that resonates. Speak to their deeper desires, not just their immediate problems. Communicate the outcome your product delivers and why you’re different from the rest. 5. Assemble Your Launch Team You can’t do it alone, and you shouldn’t. A successful launch involves stakeholders across the company. Use the RACI framework to assign clear roles. 6. Clear Objectives Too many teams dive into a launch without defined goals. And that’s why they miss the mark. Set clear objectives and key results. 7. Distribution Channels Many teams fall into the trap of trying to be everywhere; LinkedIn, email, ads, you name it. Reality check: Most startups only have 1-2 effective distribution channels. Find yours and double down on it. 8. Launch Milestones Planning your entire launch around individual tasks will overwhelm you. Instead, focus on major milestones and build a work-back plan. Some key milestones to include: Early access launch → Customer launch → Kickoff meeting. 9. Bill of Materials Your Bill of Materials is the content engine of your launch. Focus on: → Writing the message they want to hear → Designing visuals that captivate and appeal to them → Creating email sequences tailored to every user flow 10. Sales & Customer Success Teams Too many launches fail because these teams are looped in at the last minute. Enable them early with a messaging deck, internal FAQs, and demo materials... And they’ll become powerful advocates for your product. 11. Launch Day Make sure everything is launched smoothly and on time. If you achieve early wins, be the first to celebrate them and rally the team. And don’t forget to keep pushing the momentum forward. There's much more in the deep dive: https://lnkd.in/eB7s6umA If you don't plan your launches, even the best products will fail.

Interview Conversation Role: RTE in #SAFe Framework Topic: Preparation for PI Planning 👴 Interviewer : "PI Planning is around the corner. How would you ensure it's well-prepared and smooth for everyone involved?" 🧑 Candidate: "I’d make sure the teams know the agenda and are clear on their tasks." 👴 Interviewer: "Let’s add a layer. Imagine stakeholders have conflicting priorities, and teams are feeling unclear on dependencies. A lack of alignment could derail the PI. How would you structure your prep to tackle these challenges?" 🧑 Candidate: "I’d send out reminders about the PI objectives and ask teams to review their backlogs." What an effective Release Train Engineer should say: ---------------------------------------------------------- ✨ PI Planning success starts with comprehensive prep. I’d first facilitate a Pre-PI alignment workshop with Product Management, System Architects, and key stakeholders to clarify objectives and identify any competing priorities. This helps shape a single, clear vision for the PI. 💬 I’d then work closely with Product Owners and Scrum Masters to conduct a ‘Feature Readiness’ session to ensure all feature backlogs are prepared, dependencies mapped, and objectives aligned with our business goals. ✔ For example, in a previous ART, we held cross-team syncs in the lead-up week to discuss shared dependencies, which prevented delays and miscommunication during PI. 📊 Additionally, I’d ensure that the Solution Train and System Architects host architecture readiness sessions, providing teams with the necessary technical context. Any major risks or unknowns are surfaced early, allowing us to address them in a risk management session before PI Day. 🏹 Impact: With thorough preparation, everyone enters PI Planning focused, equipped, and aligned. This approach mitigates last-minute roadblocks, clarifies dependencies, and ensures that the ART can plan realistically, setting us up for a successful PI execution.