The epic life cycle: It's not done until you remove the feature
In the dynamic realm of software development, I want to shed light on a fundamental truth that often goes unnoticed: projects, epics, and features are never truly finished until you intentionally remove them from your product. This concept may seem straightforward, and many software professionals would concur. However, the challenge lies in how we structure our processes.
All too often, I've witnessed a common scenario: teams confine features to projects that must eventually be marked as "Done." This practice is deeply ingrained and extends beyond the product development team; it traces its roots back to traditional project management practices and financial considerations. The issue arises when it comes to accounting for ongoing support and maintenance for these features.
Traditionally, ongoing support is a challenge to quantify, leading many to overlook it and expect team members to shoehorn it into their day-to-day responsibilities. This approach can breed resentment and hinder productivity. But here's the thing: there's a better way.
Why not establish distinct phases that account for ongoing support, continuous improvement, or potential removal right from the outset? In this post, I propose a paradigm shift—a structured approach to the stages of an epic, feature, or project. My aim is to encourage you to codify these steps into your existing tools and processes, ensuring that you don't merely mark things as "Done" to avoid addressing them again.
By embracing this proactive mindset, we can pave the way for more sustainable and efficient software development practices. Let's dive into these stages and uncover a path to software excellence that doesn't leave room for neglecting ongoing support and improvement.
About Hierarchy and it’s importance
When your product gets to a certain maturity level you start getting a back log of big ideas you could do. These ideas are much bigger then a simple sprint task. It’s important to separate out these bigger ideas from your sprint tasks, because they are going to have a much different flow, and will have a lot of sprint tasks associated with them. One common issue is that people will just label these items as X-Large or Really Big, but leave them in the same bucket as all the other sprint tasks. Since they are so big they will most certainly get left behind. So the first step is to identify your big themes or groupings of works and find a separate place to list them. Review the from Chaos to clarity post to learn move about cleaning up your backlog, including grouping things into projects.
Stages of Software Development Epics
Backlog - When new ideas land
Our journey begins in the backlog—a space where creativity knows no bounds. Here, new ideas and potential features take root. However, not all ideas make it past this stage. I evaluate each one meticulously, considering feasibility and potential impact. Only the most promising ideas move forward to the next phase.
Discovery - Is this something worth doing?
Once an idea emerges from the backlog, it's subjected to a rigorous discovery phase. The question at this stage is simple but profound: Is this something worth doing? To answer it, I delve deep into research, gather data, and assess market dynamics. This critical evaluation ensures that the idea aligns with the project's overarching goals and vision. In this stage you’ll be talking to stakeholders, clients, and subject matter experts to better understand the problem. At the end of the discovery stage you should have a solid problem statement.
With a validated idea in hand, it's time to chart the course. The planning stage involves creating a comprehensive roadmap that outlines the necessary steps to transform the idea into a reality. I define the project scope, set clear goals, and establish a realistic timeline. This is where you would write your product requirements doc. You should have a rough idea of the proposed solution at this stage.
Design is where the blueprint for the product takes shape. This encompasses user interface (UI) and user experience (UX) design, ensuring that the software not only functions seamlessly but also looks and feels exceptional. User satisfaction starts here. For technical products this might include API design or technical architecture designs.
The development stage is where the real magic happens. Armed with a well-crafted design, the development team gets to work, coding and crafting the software. Agile methodologies guide the process, allowing for adaptability to changing requirements.
Post-development, it's time for rigorous analysis. Data is gathered, tests are conducted, and the software's performance is thoroughly assessed. Did it meet the initial goals and expectations? This phase provides invaluable insights for future decisions.
Retrospective - Did it achieve its goals?
After deployment, a retrospective is essential. Here, we reflect on the journey. Did the project achieve its goals? What worked well, and what could be improved for the next epic? It's a time for learning and growth.
Maintain - Ensure it continues to work as intended
Software isn't static; it evolves. The maintenance phase involves ongoing support, bug fixes, and updates to keep the software running smoothly and users satisfied. This includes continued analysis to ensure the feature continues to solve the problem.
The "Remove" stage, acknowledges that sometimes less is more. In this stage, we carefully evaluate and consider removing obsolete or redundant features to streamline the product, reduce complexity, and enhance the overall user experience.
In the dynamic world of software development, each epic journey is a unique adventure. By following these stages—from idea inception in the backlog to critical retrospectives and even the removal of unnecessary elements—we can navigate this ever-evolving landscape with confidence. It's a journey that requires adaptability, continuous learning, and a commitment to delivering exceptional software products. So, let's embrace these stages and embark on our next epic, knowing that success awaits those who navigate the path thoughtfully and skillfully. Happy coding, fellow adventurers! 🚀