This post looks at defining a blended innovation life cycle & an innovation readiness score – It builds on the previous post on Blended Innovation Model
Are we there yet?
Sharing progress on a revolutionary (or even an evolutionary) innovation becomes a challenge when not everyone speaks the same language – Core teams have worked the way they have for years and the MVIT operates with a completely different rule book (or at times; no rules).
A quick reference to the differences between the Core and the MVIT from a previous Blended Innovation Model post:
You are here (X)
Core teams generally function as a well-oiled machine and follow a SDLC that covers some, if not all of the following:
When looking at the interplay between the Core and the MVIT in a blended innovation engine we should look at how the MVIT lines up its efforts in relation to the existing SDLC (the well-oiled machine everyone is used to); Ideally we end up with two independent cycles that intersect or allow the movement (of products from the MVIT into the Core).
If we list out the various stages across development and implementation and assign responsibilities in the context of Revolutionary vs. Evolutionary innovation projects, we get a holistic view of where and when the MVIT is engaged.
For revolutionary/exploratory innovations – the MVIT (only) will start with POC’s and pilots in a vacuum to prove the value, and once it does, it will look at integrating with core to release the product in a limited scope for additional customer validation. Once larger validation has been performed the product will move to the core team for general availability. The matrix below helps illustrate the primary team(s) responsible for the slot/phase.
For Evolutionary/ Growth / Acceleration innovations – the idea has already been validated and the primary purpose in MVIT’s involvement is to help rapidly pilot and accelerate the development so that It can be integrated and added without negatively impacting the product roadmap. The Pilot and Limited stages are identical as there really isn’t a pilot phase. Once larger validation has been performed the product will move to the core team for general availability. The matrix below helps illustrate the primary team(s) responsible for the slot/phase.
Blended Innovation Life Cycle
Based on MVIT’s roles and efforts above – we can summarize and group MVIT’s role and efforts into 4 major phases and refer to it as the Blended Innovation Life Cycle (BILC):
During the MVP phase, the MVIT is focused on three progressive stages:
- Inception: Defining a very vague or high level idea that might seem like a good fit for the MVIT to work on.
- Fit: Refining the very vague/high level idea to answer “Does it fit?” – if we were to build this, can it integrate with the core product? How would it integrate? The focus here is on reaching an absolute Yes/No assessment on fit regardless of answering things like “when does it fit” or “how long will it take”.
- Pilot: MVIT will move forward and hack together a pilot that can be used for internal demos to showcase the idea – majority of the work is likely hardcoded or manually configured – the goal isn’t to make a finished product, but rather quickly show something that can help explain the idea and value add
It’s very likely that the MVIT never gets to stage 3 for majority of the ideas – but for the ones that do make it to the third stage – they then move to the next phase: “Viability”.
In the “Viability” phase the focus is on (internal) Customer Validation – the MVP is shown to the product team and other product roadmap stakeholders (like sales leadership) to assess business value. The product team would look at how the idea would enhance the product roadmap and would help define how the product would integrate with the core. A decision is made to move forward and to introduce to additional customers via limited availability.
In the “Production” phase, the focus is around Limited Availability stage – the MVIT works with the Core Product team to build a closer integration where architecture, integration approach, development, QA implementation and pre-sales plans are defined, development and implemented (by MVIT and Core). For customers who enter limited availability, the MVIT is responsible for supporting its product(s) where MVIT will not only provide front line support where needed, but also deploy and maintain deployment environments.
The “Scale” phase is focused on two final stages
- Transition: where the product and its support is transition to the core team – all artifacts, such as code, support guides, implementation guides, etc. are documented and handed over.
- Mainstream deployment: where the core team works with operations and support team to take over deployment and support.
By defining the “BILC” in the manner we did – where the core team becomes an integral part of the innovation directly after the pilot, we help implement a process that allows a natural alignment to the Core’s SDLC and we don’t end up with a team that’s releasing under-baked products that don’t integrate well with the core product.
We can also number each stage in the “Blended Innovation Life Cycle” to obtain an “Innovation Readiness Score” and we can then use both the score and the phases to help report on the readiness of an innovation and figure out where we are and what’s next.
This post looks at the blended innovation model within an enterprise – it expands on the previous post on A Start-up within an Enterprise
In a market segment/space, the portion that’s captured by an enterprise is its core. Outside this core is the new growth opportunity (the white space) that the enterprise has not (yet) captured; there can be additional enterprises in the same segment/space and over time the segment/space can increase and/or decrease – for the purpose of this post, we will assume that the segment/space stays the same.
For most (enterprise) organizations, the core is grown by the natural evolution of the products/services: as customers use the products/services their requests transform the roadmap. With (somewhat) uniform time and resources, focusing on everything all the customers ask for becomes a challenge and priority is given to the top tier customer base.
Most enterprises operate this way due to the low risk, as the needs have already been validated (due to customer demand). This type of innovation falls under evolutionary innovation.
For startups, the entire “new growth” opportunity becomes the initial target; as time goes on and effort is put into defining the product-market-fit a smaller “core” emerges. In many cases the (perceived) core might pivot several times (see below A -> B -> X) prior to eventually finding its eventual core (if it doesn’t completely fail by then).
The risk is much higher as customer validation still needs to happen, and significant time is spent in validation/product-market-fit. This type of innovation falls under revolutionary innovation.
When these two behaviors exist within their own respective entities (startup and enterprise) and are in the same space/segment they form a complementary relationship – which often results in the demise of the enterprise (unless the enterprise acquires the startup). The customers that are lower in priority for the enterprise move to the startup, either because the product is too feature rich, the needs are not met or they feel that the enterprise has become too big for them (low end disruption, See Clayton Christensen’s work on disruption). As they move out, the enterprise sees that as an opportunity to expand to the new (higher revenue) opportunity and move away from the lower end. As time goes on, the enterprise’s core continues to move outwards and the startup continues to encroach into the enterprises core until the enterprise has nothing left (eventually leading to the startup becoming its own enterprise).
The above describes the outcome when the two innovation modes are two different entities – but what if they were to be combined within an enterprise as a strategic initiative?
By making it a strategic initiative to combine both of these models within an enterprise to achieve a blended innovation engine; enterprises can greatly improve their competitive advantage and also accelerate their organic growth. With executive sponsorship, an additional dedicated team would need to be created (the MVIT).
A simple matrix can be put together to understand the differences between the core and the MVIT:
The interplay between the teams in a blended model is outlined below (to cover additional complexity a multi-core/multi-BU enterprise is used).
An enterprise that has multiple BU’s may cover different verticals in its “new growth” space; however, since each core operates in an evolutionary way, most do not cash in the opportunity to build organically within the shared (white) space.
There also needs to be some sort of “idea allocation engine” so that white space ideas (shared and non-shared among various BU’s), non-core customer requests and other exploratory ideas can be funneled into the appropriate team as there may be several ideas that seem “revolutionary”; but in-fact, they are actually more evolutionary in nature. The VCG (venture champion group) can help be the funnel to ensure that the MVIT is working on the appropriate opportunities (see:A Start-up within an Enterprise).
Once the idea generation and intake funnel is in place, the MVIT can begin piloting product for customer validation by releasing small pilots in the various spaces that iterate in functionality over time with customer involvement (as the viability becomes more obvious).
Developing the pilot in a common language/platform will help with the transition and once the pilot is ready, it would be supported by the MVIT. Should a pilot gain significant traction, the MVIT would continue to support it in a limited availability engagement and once a MVIT produced product enter limited availability, the BU should start planning for support, integration, release and productization under GA.
The integration/transition process from MVIT to Core will likely be significantly more involved than the other efforts.
Depending on the release and GA schedule, the Core will absorb the customer-validated pilot into the core – providing it a competitive advantage that was accelerated with the help of the MVIT that it would otherwise not have had.
A blended innovation model can greatly improve the competitive advance for an enterprise and also accelerate its organic growth. To successfully implement a blended innovation model it must be taken on as a strategic initiative, backed by executive sponsorship, have an additional dedicated team (MVIT), an idea allocation engine and a process for transition so that the investments in the blended model can be realized.
Evolution: a process of slow change and development.
Revolution: a sudden, extreme, or complete change in the way people live, work, etc.
Evolutionary innovation results in steady gradual growth over time whereas Revolutionary innovation results in rapid growth that eventually fizzles away (it needs another revolution to survive, or in most cases will become evolutionary over time). Both have risk – as a revolution can fail and an evolution can die out. (quick sketches to illustrate this below)
A blended model lets an organization take in (successful) revolutions and accelerate its growth, allowing it to extend its evolutionary life.
To accelerate innovation – both evolutionary and revolutionary should be leveraged and be a part of an organizations growth strategy; but thats easier said than done.
To build up and reflect on the previous learnings/posts the following is a summary on some crucial points that should be taken into account:
- Define the process and rules for evolutionary innovation and revolutionary innovation (the core team focuses on evolutionary and the MVIT focuses on revolutionary) as a strategic effort.
- Obtain executive sponsorship for the MVIT.
- Define GTM strategy and process for revolutionary innovations
- Communicate strategy to both top and bottom and get buy in.
- Budget and fund the MVIT.
- Reduce dependency and ensure the MVIT is a complete unit (has all the resources it needs and does not rely on others)
- Focus on execution.
- Optimize often.
- A dedicated “innovation” team that works outside the company’s core “processes” (a.k.a. red tape) does not exist
- You share or borrow resources from other teams who help out in addition to their core duties or have a “20% time” policy.
- A budget to spend on non-core R&D and other expenses was never factored in and/or approved.
- People expect the output from this “innovation” team to follow the same rate of return as your core product teams.
- You plan on engaging other (Architects, DevOps, Eng., etc.) core teams after all the work is done to come up with some sort of transition plan.
- No committed initial plan on what you will go after initially.
- No pass/fail metrics were setup.
- You do not have complete buy in from the top.
While all of the reasons above carry weight, if I had to pick one, it would be the first reason – the lack of a dedicated innovation team.
For most enterprises that have a part-time innovation team; all that innovation gets pushed aside when shit hits the fan – then its all-hands-on-deck – innovation, becomes an afterthought.
From a previous post: “It’s important for an enterprise to have a team that focuses on innovation as a “full-time strategic” activity and not as a “part-time ad-hoc” effort in order to have a greater chance of success with innovation – here is why: 75 % of venture-capital-backed start-ups fail; and 50% of backed start-ups make it to their 4th year. These startups, usually consist of dedicated entrepreneurial teams trying to build something, spending 100% of their energy, every minute of every hour trying to make it successful – they are in it full time. If a startup’s “full-time” innovation effort has such a low rate of success, what will be the success rate of a part-time effort?”
A dedicated team must be created if an enterprise wants to make innovation a strategic effort. If you have no one fully focused on innovation, you’ve decided not to focus on innovation.
Before we dive back into defining an approach that mixes Product and Custom focus, we should probably ask “How does one focus on the customer?”
In an ideal world there are no defects; but since there are, and customers expect them to be resolved, an ideal approach balances itself between being proactive and reactive; proactively resolve reported/discovered defects and appropriately manage escalations. On the surface, one focuses on the customer by making sure that the defects are fixed before a customer reports them and if a customer reports them, they are addressed promptly (top priority of course) and the customer is satisfied – below the surface, defect management and prioritization play an important role towards our customer focus as this tells us how soon we can (and will) actually resolve defects.
The list below doesn’t capture all possible approaches in resolving defects; it captures approaches that I have had some experience with (I recommend that you certainly do not try the first one):
Don’t resolve them
- Push the defect to the original developer, or the developer most familiar with the functionality for resolution.
- Allocate time for the first available developer to pull a defect in and resolve.
- Have a defect duty rotation where a person (or team) resolves only defects for a time period
- Have a dedicated team for defect resolution.
- … Some other create ways to resolve reported defects..
Always push to most familiar
Pushing the defect to the most familiar sounds like a great idea and in many cases it is because the one most familiar would be able to resolve quickest and positively impacts customer experience. The issue with this approach is that the most familiar person might be involved with something that has a higher priority than this defect, or is out on PTO and would not be able to resolve for another 2 weeks. Let’s say it takes someone familiar with the code to resolve in 1 hour but takes someone not familiar with the code 6 hours. If the defect goes to the person currently tied up and is most familiar, the customer will have to wait a minimum of 2 weeks + 1 hour; however, if it goes to the person not currently tied up and is least familiar, the customer will have to wait a minimum of 6 hours. Being collaborative and available for the team may improve the turnaround time on average, but a hard coded “always send to the one who created it” may not be the best approach.
Allocate time to pull
Allocating time towards the end of an iteration, development or whatever, towards “defect resolution” allows the team to first get the scheduled work out of the way, and “if” there is time, someone may pick something up from the backlog of defects. The issue with this approach is that if the development cycles are fully booked (maybe there is a hard date) and there is any risk or complexity that might lead to developers putting in all they have to meet the delivery; defect resolution gets thrown on the back burner. In most cases where the approach is “allocate time to pull defects”, the unspoken rule is that new products come first, defects second – unless; where the “unless” is for escalations and chaos/fire-fighting instances. For agile teams, if the time allocated towards defect resolution does not change from sprint to sprint, then there is no impact to velocity; however, if the time allocation is not fixed the velocity can get impacted depending on how much time is spent on defect resolutions (usually hours) vs. features (SP’s)…. You could estimate defects in story-points but this can lead to additional issues that will need to be worked out… i.e. do you really want to hold a sprint back? etc..
Defect resolution duty rotation
For a given time (usually the span of a sprint) a developer within a team, or a whole team themselves will be on defect resolution duty; once the time span is over, someone else (or a different team) takes on defect resolution duty and so on. This helps cross-train and helps make everyone familiar with the code base. It can also help improving code quality since everyone is learning from everyone’s mistakes and provides a great collaboration platform; while it does have some great benefits it does introduce some challenges. A significant issue is that developers and teams lose traction as they switch focus from “new product” to “old product”; the interruption can cause a delay since the developer(s) will need to get back to where they were after the rotation is over. For organizations that have many teams or larger teams this may be less of a concern since the rotation might happen every few months; but even then, when it does happen it does have a negative impact.
Dedicated team for defect resolution
The thought on this one is that if there is one team solely focused on supporting “released software” (defect/engineering sustaining team) and other team(s) focused on creating “new software” (Feature teams) that you end up with a two-tiered development approach where both the product and the customer can be focused on. The feature (new software) team is rarely impacted by defects from the “live” world and they can always focus on delivering new product; the defect/engineering sustaining team is dedicated to resolving defects and is not tied up with new features. The issue with this approach is that no one aspires to be a “defect fixer”, developers want to “develop” new and innovative “features” (or at least I did); It is possible to make this work if more attention is given to down-time cross-training, root cause analysis, collaboration, role rotations, etc… (I have seen teams evolve this approach into a “defect resolution duty rotation” approach)
In addition to the above, there can also be hybrid approaches that mix various approaches, i.e. defect resolution duty rotation with an added “pager duty” where someone (not on defect duty) is on-call but in general there is no “incorrect approach”; however:
Any approach can become incorrect when developers are forced to accept an approach that they do not agree with (or understand).
Any approach that is going to be implemented should be discussed with the teams that will be implementing it, focus on and explain the “why”. When an approach does not work, try to adjust it or try something else!
“if the code repository is an “elephant” and new code is peanuts being fed to this elephant by the other guys, then I am always cleaning up after the elephant; who wants to be a shit cleaner forever?”.
We are usually torn between building more “product” or satisfying the “customer”.
Prioritize Customer (maintaining product)
Fix and release to save the world
Prioritize Product (building more product)
Plan and build to a schedule
When you focus on product, you have a certain “amount” of product that needs to be built within a sprint (time box); you can plan for fixes by leaving some room for the defect backlog, but features come first – then come fixes, and the work is usually fixed where people know what they are working on for the sprint. In this scenario most will usually package after the sprint is over (test and release)
When you focus on customer, you have to fix and get the fix out the door ASAP. Priority is given to the most critical fix and/or customer and things will be packaged (test and release) as soon as appropriate and/or possible.
Some solve this by having a sustaining engineering team, but who really wants to only fix defects?; others use a mix of cross-functional or functional teams and adjust as needed, but this can be disruptive.
If you chose to “adjust as needed” (be agile) you will introduce some chaos every now and then but this can be minimized by having “plan of action”. How you adjust as needed and what type of “plan of action” you need also depends on what type of process you follow and what your focus is; is your culture focused on product? or is your culture focused on the customer? Depending on whom you ask (their role) within an organization, you may get different answers.
If you follow “Scrum” then your work queue is mostly “push” defined, where work is planned and pushed into a sprint/iteration before its worked on.
If you follow “Kanban” then your work queue is mostly “pull” defined, where work is pulled and worked on.
In an ideal world, one would have a process that allows the focus on both, the product and the customer. A process that allows you to “build what you say you will build” but also allow you to focus on “what is important right now”; such a process would mix Scrum and Kanban, giving you, ScumBan. The idea of a Scrumban is not new; there are books and many talks/posts regarding this. How Scrum and Kanban are merged together depend on the person who is cross-breeding the processes and what problem(s) they are trying to solve; I named my implementation “RAPID” for “Real-time Actionable Prioritized Individual Delivery”.
In my next post around RAPID, I will go over some examples that helped define the how and why behind RAPID and how it would be used in a team that wants to focus on both, the product and the customer.
People growth – Old blood vs New blood
I wrote my first post here on Jan 23 2011 and that post was titled “Startups – importance of your team“; Its been a little over 2 years since I wrote that post.
Most of us work 5 days a week, putting in about 8 or so hours a day (we will stick to the average/norm here). We come back home in the evening to spend anywhere from 1 to 4 hours with our family/friends.
When friends and/or acquaintances form a startup, the long hours and the close working relationship build on existing relationships and everyone at the startup works as a “family”; but what happens when there are no existing relationships? or what happens when you already have a family and someone new tries to come in? Wouldn’t it be awkward if you were out with your family/friends and a stranger joined your group and just hung out? would you be your self? most wouldn’t.
So how do you take an existing family (a started up culture) and add newer members to it? How do you mix the two so that you do not end up with friend circles?
I have 4 simple attitudes/behaviors that I build my base on:
“We are not that different”.
The new member see’s a whole new planet, different people, cultures, processes, jargon, etc. The first step should be to look for similarities between what they know and what they should know. For my teams I use a buddy system and its usually the previous newest member who buddies up with the new member. They go over materials, documenting anything new that might come up, go for lunch, talk about process, go through the who’s-who, engage the new person in conversations with the other team(s); they try to get to know this person as if they were dating each other.
“We got this, lets work on it together”.
How do you start work? where do you start? who do you ask? Scary questions for someone looking under the hood of something they do not understand. Here is where the buddy comes in again; during stand ups and sprint planning the buddy might offer “we can work on this together”, or someone else on the team might say “hey this is a good problem for me to show you how xyz works, and we can solve it”… they get the knowledge, they figure out how to start, they experience the process and they know how to close it. Build trust and accountability.
“Your team mentioned that you are catching on so quick, what can we improve?”
Over communicate reinforcement of team acceptance, ask for ideas on what can be improved, engage the new member; engaged employees have ideas and feedback that they want to share, things they have questions about.
“You are doing great, let me share my vision on how you play an important role to the team”
Setup a growth plan that’s challenging and communicate that it may be challenging and track to it. I like to plan for the 1, 3, 9, 12 and beyond and use data obtained directly or through peer feedback to gauge fit; if there is going to be tissue rejection, you need to act fast and figure out what you need to do to make it work successfully.
These 4 steps get you on track but you will still need to build additional on-boarding processes (around material and core knowledge ) that will grow the employees product knowledge. Its also important to keep your existing members in mind when you optimize culture as you want to grow the existing employees as well and not just the new ones.
At the end of the day it helps if we recognize that the teams we work with are more than just “Random people”; they are people we spend several hours with, they are friends, people we trust, can openly collaborate with and people we want to continue to work with.
When one finds a team they can work with for the rest of their life and can call family, its no longer “work”…it’s just a large friends & family gathering where they just happen to be working on something together and having fun.
We should all build and be part of such teams.