Let's get one thing straight upfront - we LOVE Lean Development. It's empirically customer-focused, thoughtful, and in the App Development world - maps perfectly to process that is required to bring an App to market and more importantly, enhance and innovate on that App after its initial launch.
More often than not, we see too many App Development projects (and their subsequent products) imbued with too much...well...fat. Too many requirements, too many features, and in most cases simply over-architected to the point where the content and the goal of the App gets lost. We've talked a lot about starting every App programme with a well defined and extremely simple "Application Definition Statement" - a very clear line in the sand that states what we are building, for whom, and why. It's such a no brainer that it's amazing so many App Developers seem to completely skip this step in the goal of launching the most feature-rich, shiny new App to market in hopes of catching fire.
But here's the thing - the Apps that DO catch fire are not feature-rich or over-architected. They're basic, lovely, and solve a clear problem.
And it's almost impossible to achieve that beautiful simplicity using typical software development - or heck, any traditional product development process - as inevitably the requirements and build phases will become unnecessarily bloated. Yes, Agile acolytes - even the Agile Development process falls victim to the potentially crippling effects of what we call - the "1.0 Pedestal".
Simply put, this "1.0 Pedestal" is the virtual altar the first product launch (i.e. the 1.0 Version) is placed upon, causing the development and requirements gathering process to stretch out to a point where the product inevitably becomes complicated and overly feature-laden. What occurs is an agonisingly long requirements period (several months in some cases) followed by an extended development cycle that finally produces a first product that has never been properly tested or validated with real audiences.
That's why most Apps turn into "fire and forget it" propositions. After all, budgets and resources are typically exhausted by the time the 1.0 Version launches - so who has the time, money, or energy to focus on subsequent updates?
A crucial fact to remember is that most App don't "hit their stride" and begin to generate serious interest and downloads until later versions (often Version 1.4 onwards). So if you deplete your resources (and ideas!) in the 1.0 Version, how will a proper roadmap of enhancements and changes be established?
More importantly, by pushing a 1.0 Version into the world rapidly and with a minimum set of features you get the added benefit of immediate and highly valuable user feedback and usage statistics - crucial information that will inform the direction and scale of subsequent releases. At Entropy we call it the "Minimum Base App" (our take on the Lean Development 'Minimum Viable Product' or MVP). By focusing only on our key goals and answering our Application Definition Statement with as few features as possible, we are not only able to hit the marketplace quickly - but we allow real users to inform our roadmap, features, and ultimately the App's lifecycle.
We call it the Build>Measure>Innovate Loop - and again, there's nothing here that's not been said by Lean Development practitioners - but it's a subtle translation of the process to App Development.
And for our clients we can confidently say - it's made all the difference. With the benefit of a rapid requirements gathering and development cycle for a Minimum Base App (MBA) we have the time, budget, and available energy to map out a proper App Roadmap (one that will ensure key features and enhancements for a number of future releases) whilst retaining the flexibility to pivot to the real data and demands of actual users.
As an added benefit we've found our clients remain more excited, committed, and intricately involved in the lifecycle of their Apps.
Again, it's nothing new - but as App Developers we have a lot to learn from the Lean Development Methodology - a process that ensures we are focused, graceful, and creating a simple and gorgeous App Experience with every line of code we write.
And for a "process", you can't get much better than that.