Sunday, December 3, 2017

Sustainable Information Systems Development and Technical Debt




1. Introduction


This short blogpost is a revisit of the concept of sustainable IS development in the digital age, that is in the age of constant change. Sustainable development for information systems is how to make choices so that building the capability to deliver the required services today does not hinder the capacity to deliver a few years later the services that will be needed then. It is a matter of IS governance and architecture. Each year money is allocated to building new systems, updating others, replacing some and removing others. Sustainable development is about making sure that the ratios between these categories are sustainable in the long run. It is a business necessity, not a IS decision; sustainable IS development is a classical short-term versus long-term arbitrage.

The initial vision of sustainable IS development comes from a financial view of IS. In the word of constant change, the weight of complexity becomes impossible to miss. This is why the concept of technical debt has made such a strong comeback. The “technical debt” measures the time and effort necessary to bring back a system to a “standard state” ready for change or upgrade. In a world with little change, technical debt may be left unclaimed, but the intensification of change makes the debt more visible. The “debt” metaphor carries the ideas of interests that accumulate over time: the cost and effort of cleaning the debt increases as the initial skills that created the system are forgotten, as the aging underlying technologies become more expensive to maintain and as the growing complexity makes additional integration longer; more difficult, and more expensive.

From a practical point of view, complexity is the marginal cost of integration. Complexity is what happens inside the information systems, but the most direct consequence is the impact on the cost when one needs to change or to extend the system. If you are a startup or if you begin a new isolated system, there is no such complexity charge. On the other hand, the cost of change for legacy system is multiplied by the weight of integration complexity. Complexity may be measured as the ration of the total effort of building and integrating a new function into an information system divided by the cost of developing this new function itself.

A dynamic view of sustainable IS development, therefore, needs to take complexity into account. Sustainable development needs to keep the potential for innovation intact for the next generations (in the software sense, from months to years). Complexity and change do not invalidate the previous financial analysis of sustainable development based on refresh rate and obsolescence cost, they make it more pregnant because the financial impact of technical debt grows as the change rate grows. Other said, a static sustainable development model sees change as a necessity to reduce costs whereas a dynamic model sees the reduction of complexity as a necessity to adapt to external change.

The post is organized as follows. The next section recalls some of the key ideas of “Sustainable Information System Development”. SD initial framework is drawn from a model of IT costs that looks at the cumulative effects of system aging. The purpose of SD is to derive governance rules to keep the budget allocation stable in the future and balanced between the maintenance of the current system and the need to adapt to new business requirements. Section 3 provides a short introduction to the concept of technical debt. “Technical debt” measures the effort to return to a “ready for change” state and if often measured with days/months. Time is a very practical unit but it does not make it easier to master technical debt, especially when complexity is involved. Section 4 adds the concept of complexity to the sustainable IS model. Cleaning technical debt is both defined as returning to a “standard” – often defined by rules and best practices – and reducing integration complexity. There is no such thing as a standard here, this is the essence of IS architecture to define a modular target that minimizes integration complexity.



2. Sustainable IS Development


Sustainable IS Development is a metaphor that borrows from the now universal concept of « sustainable development »:

  • The following definition was proposed by the Bruntland commission: "Sustainable development is development that meets the needs of the present without compromising the ability of future generations to meet their own needs.
  • This is a great pattern to define sustainable development for information systems: “Sustainable IS development is how to build an information system that delivers the services that are required by the business today without compromising the ability of meet in a few years the needs of future business managers.”

This definition may be interpreted at the budgeting level, which makes it a governance framework. This is the basis of what I did 10 years ago – cf. this book or the course about Information Systems that I gave at Polytechnique. It may also be interpreted at the architecture level, as shown in the book “Sustainable IT Architecture: The Progressive Way of Overhauling Information Systems with SOA” by Pierre Bonnet, Jean-Michel Detavernier, Dominique Vauquier, Jérôme Boyer and Erik Steinholtz. In a previous post almost 10 years ago, I proposed a simple IS cost model to derive sustainable IS development as an equation (ISSD). I will not follow that route today, but here is a short summary of the three most important consequences of this model.

ISSD model is based on a simple view of IS, seen as a collection of software assets with their lifecycles and operation costs (in the tradition of Keen). Governance is defined as an arbitrage between:

  • Adding new components to the system, which is the easiest way to add new functions modulo the complexity of integration.
  •  Maintaining and upgrading existing components.
  • Replacing components with newer versions
  •  Removing components – the term “applicative euthanasia” may be used to emphasize that old legacy applications are never “dead”.

ISSD model is a set of equations derived from the cost model that express that the allocation ratio between these four remains stable. The main goal (hence the name “sustainable”) is to avoid that consuming too much money today on “additions” will result in the impossibility to evolve the information system tomorrow. This simple sustainability model (ISSD) shows that the ability to innovate (grow the functional scope) depends on the ability to lower the run cost at “iso-scope”, which requires constant refreshing.

At the core of the SD model is the fact that old systems become expensive to run. This has been proven in many ways:

  • Maintenance & licence fees grow as systems gets older, because of the cumulative effect of technical debt from the software provider side, and because at some points there are fewer customers to share the maintenance cost.
  • Older systems start to get more expensive after a while, when their reliability declines. There is a famous “bathtub” curve that shows the cost of operations as a function of age, and while maturation helps at first (reducing bugs), there is an opposite aging factor at work.
  • The relative cost of operations grows (compared to newer system) because legacy technology and architecture does not benefit from the constant flow of improvement, especially as far as automation and monitoring is concerned. Think of this as the cost of missed opportunity to leverage good trends.

The good practice from the ISSD model is to keep the refresh rate (which is the inverse of the average application age) high enough to benefits from HW/SW productivity gains to accommodate for the necessary scope increase. Remember that “software is eating the world”, hence the sustainable vision of IS is not one of a stable functional scope. Sustainability must be designed for growth.

The average age of your apps has a direct impact on the build/run ratio. This is a less immediate consequence of the ISSD model, but it says that you cannot hope to change the B/R ratio without changing the age of your apps, hence without the proper governance (whatever the technology vendor will tell you about their solution to improve this ratio). This is another of stating what was said in the introduction: Sustainable IS development is a business goal and it is a matter of business governance.


3. Technical Debt



The concept of technical debt is attributed to Ward Cunningham even though earlier references to similar ideas are easy to point out. A debt is something that you carry around, with the option to pay it off which requires money (effort) or to pay interest until you can finally pay off. Similarly, the mediocre software architecture that results either from too many iterative cycles or shortcuts often labelled as “quick and dirty” is a weight that you can either decide to carry (pay the interest: accept to spend more effort and money to maintain the system alive) or pay off (spend the time and effort to “refactor” to code to a better state). For a great introduction to the concept of technical debt, I suggest reading “Introduction to the Technical Debt Concern” by Jean-Louis Letouzey and Declan Whelan.

The key insight about technical debt is that it is expressed against the need for change. I borrow here a quote from Ward Cunningham: “We can say that the code is of high quality when productivity remains high in the presence of change in team and goals.” The debt is measured against an idea standard of software development: “When taking short cuts and delivering code that is not quite right for the programming task of the moment, a development team incurs Technical Debt. This debt decreases productivity. This loss of productivity is the interest of the Technical Debt”. The most common way is to measure TD with time, the time it would take to bring the piece of code/software to the “standards of the day” for adding or integrating new features.

The concept of “interest” associated with Technical Debt is all but theoretical. There is a true cost to keep the technical debt in your code. Although TD is subjective by nature (it measures an existing system versus a theoretical state) most of the divergences that qualify as “technical debt” have a well-documented cost associated to them. You may get a first view about this by reading Samuel Mullen’s paper “The High Cost of Technical Debt”. Among many factors, Samuel Mullens refers to maintenance costs, support costs or labor costs. One would find similar results in any of the older cost models form the 80s such as COCOMO II. Another interesting reference is “Estimating the size, cost, and types of Technical Debt” by Bill Curtis, Jay Sappidi and Alexandra Szynkarski. This CAST study focus on 5 “health factors” (that define the “desired standard”) with the following associated weights:

  • Robustness (18%)
  • Efficiency (5%)
  • Security (7%)
  • Transferability (40%)
  •  Changeability (30%)

Here, TD is the cost to return to standards in these 5 dimensions and the weight is the average contribution of each dimension to this debt. Some other articles point out different costs that are linked with technical debt such as the increased risk of failure and the higher rate of errors when the system evolves.

Complexity is another form of waste that accumulates as time passes and that contributes to the technical debt. This was expressed a long time ago by Meir Lehman (a quote from the CAST paper): “as a systems evolves, its complexity increases unless works is done to maintain or reduce it”. Complexity-driven debt technical is tricky because the “ideal state” that could be used as a standard is difficult to define. However, there is no doubt that iterative (one short step at a time) and reactive (each step as a reaction to the environment) tend to produce un-necessary complexity over time. Agile and modern software development methods have replaced architecture “targets” by a set of “patterns” because the targets tend to move constantly, but this makes it more likely to accumulate technical debt while chasing a moving target.  Agile development is by essence an iterative approach that creates complexity and requires constant care of the technical debt through refactoring.


4. The Inertia of Complexity


In the introduction, I proposed to look at complexity as the marginal cost of integration because it is a clear way to characterize the technical debt produced by complexity. Let us illustrate this through a fictional example. We have a typical company, and this is the time of the year when the “roadmap” and workload (for the next months) has been arbitrated and organized (irrespectively of an agile or waterfall model, this situation occurs anyway). Here comes a new “high priority” project. As the IS manager you would either like to make substitutions in the roadmap or let backlog priority works its magic, but your main stakeholders ask, “let’s keep this simple, how much money do you need to simply do this “on top” of everything else ?”. We all know that this is everything but simple: depending from the complexity debt, the cost may vary from one to 10, or it may simply be impossible. We are back to this “integration cost ratio” (or overweight) that may be close to 1 for new projects and young organizations while getting extremely high for legacy systems. Moreover, adding money does not solve all the issues since the skills needed for the legacy integration may be (very) scarce, or the update roadmap of these legacy components may be dangerously close to saturation (the absence of modularity, which is a common signature of legacy systems, may make the analysis of “impact” – how to integrate a new feature – a project much more difficult than the development itself). This paradox is explained with more details in my second book.

A great tool to model IS complexity is Euclidian Scalar Complexity, because of its scale invariance. Scalar complexity works well to represent both the topology of the integration architecture and the de-coupling positive effects of API and service abstraction. Whereas a simple model for scalar complexity only looks at components and flows, an service-abstraction model adds the concept of API, or encapsulation, smaller nodes between components that represent what is exposed by one components to others. The scalar complexity of an information system represents an “interaction potential” (a static maximal measure), but it is straightforward to derive a dynamic formula if we may make some assumption about the typical refresh rate of each components.

This model of the expected cost of “refreshing” the information system is useful because, indeed, there is a constant flow of change. One of the most common excuse for keeping legacy systems alive is a myopic vision of their operation costs, which are often low compared to renewal costs.  The better reason for getting rid of this technical debt is the integration complexity that the presence of these legacy components adds to the system. However, this requires exhibiting a simple-yet-convincing cost model that transforms this extra complexity into additional costs. Therefore, I be back in another post with this idea of scalar complexity modelling of integration costs.

Meanwhile, the advice that can be given to properly manage this form of technical debt is to be aware of the complexity through careful inventory and mapping; then to strive for a modular architecture (there is a form of circularity here, since modularity is defined as way to contain the adverse effects of change – cf. the lecture that I gave at Polytechnique on this topic). Defining a modular information system is too large a topic for one blog post, although defining a common and share business data model, extracting the business process logic from the applications, crafting a service-oriented architecture through API, developing autonomous micro-services are some of the techniques that come to mind (as one may find in my first book).

A much more recent suggested reading is the article “Managing Technical Debt” by Carl Tashian. This is a great article about how to reduce the complexity-driven technical debt. Here are the key suggestions that he makes:

  • Keep points of flexibility. This is at the heart of a good service-oriented architecture and a foundation for microservices. However, as Tashian rightly points out, microservices are not enough.
  •  Refactor for velocity. Take this two ways: refactor to make your next project easier to develop, but also to constantly improve This is a great insight: when refactoring,  you have the insight of performance monitoring your existing system. It is easier to improve performance while re-factoring than in a crisis mode when the run-time problem has occurred.
  • Keep dependencies to the minimum. Here we see once again the constant search for modularity.
  • Prune the low-performers (usage). A simple-but-hard to follow piece of advice, intended to reduce the total weight.
  • Build with test and code reviews. A great recommendation, that is outside the scope of this post, but obviously most relevant.
  •  Reinforce the IS & software engineering culture.



5. Conclusion


This post is the hybrid combination of two previously well-known ideas:
·         The sustainable management of IT budget should be concerned with application age, lifecycle and refresh rate. To paraphrase an old advertisement for batteries “IT technology progress – such as Moore’s law – is only useful when used”.
·         In the digital world, that is the world of fast refresh rate, the inertia of the system should be kept minimal. This is why the preferred solution is always “no code” (write as little as you can), though a strict focus on value, through SaaS (letting other worry about constant change), though abstraction (write as few lines of code as possible), etc.

The resulting combination states that IT governance must address IS complexity and its impact on both costs and agility in a scenario of constant change. The constant refactoring both at the local (component) and global Enterprise Architecture level (IS as a whole) should be a guiding factor in the resource allocation process. Sustainable IS development is a business decision, which requires the ability to assess the present and future cost of IS operations, lifecycle and integration.

Because the digital world is exposed to more variability (e.g., of end-customer usage) and a higher rate of change, best practices such as those reported in Octo’s book “The Web Giants” are indeed geared towards minimizing inertia and maximizing velocity and agility. The exceptional focus of advanced software companies to keep their code minimal, elegant and modular is a direct consequence of sustainable development requirements.


This post was kept non-technical, without equations or models. It is very tempting, though, to leverage the previous work on scalar complexity and sustainability models to formalize the concept of complexity debt. Scalar complexity is a simple way to assess the complexity of an architecture through its graphic representation of boxes (components) and links (interfaces). The assess the dynamic “dimension” of technical debt associated to complexity, one needs a model for constant change. This way, the metaphor of weight (the inertia of something ponderous like a boat or a whale) may be replaced with a metaphor that captures the level of interaction between moving components.

Devising a proper metaphor is important since the “school of fish versus whale” metaphor is often used and liked by business managers. Complexity debt adds a twist about the “scalar complexity of the school of fish”: its needs to be kept to the minimum to keep the agility of the actual school of fish (for the metaphor to work). I will conclude with this beautiful observation from complex biological system theory:  The behavior of a school of fish or a flock of birds is emergent from local behaviors: fishes and birds only interact with their local neighbors (other said, the scalar complexity is low). Thus the “school of fish” metaphor is actually a great one to design sustainable information systems.





x

Saturday, September 30, 2017

Hacking Growth, when Lean Management meets Digital Software



1. Introduction



This blogpost is both about a truly great book “Hacking Growth : How Today’s Fastest-Growing Companies Drive Breakout” by  Sean Ellis and Morgan Brown – that could be qualified as the reference textbook on Growth Hacking – and a follow-up on many previous conversations in this blog  and other posts (in French) about growth hacking. There are many ways to see Growth Hacking in relation to Lean Startup. Following the lead of Nathan Furr and Jeff Deyer, I see Growth Hacking as the third step of a journey that starts with design thinking, followed by the delivery of a successful MVP (minimum viable product) and continues to growth hacking. The goal of the design thinking is to produce the UVP (Unique Value Proposition) – it is a first iterative loop that produces prototypes. The goal of the “MVP step” is to produce a “vehicle” (a product) to learn how to deliver the UVP through feedback and iteration. The growth hacking phase is about navigating towards success and growth with this MVP.
 I like Nathan Furr idea of a “minimum awesome product”, in the sense that very crude prototypes belong to the design thinking phase (to validate ideas). Growth Hacking works with a product that is “out there” with real customers/users in the real world, and it only works with a  “minimum awesome product” that delivers the value of an awesome UVP (following Ash Maurya). This says the the classical “Learn, Build, Measure” cycle is a common pattern of the three stages: design thinking, MVP building and Growth Hacking.

This post is also a follow up to the post about “software culture and learning by doing and problem solving”. Growth Hacking is a perfect example of “lean continuous improvement culture meets agile software development practice”. It is a structured and standardized practice – in the lean sense – for extracting value from a user feedback learning loop – both in a quantitative and qualitative way. As such, it is more general than typical digital products and may be applied to a large class of software products, on closed as well as open markets. I would argue that learning from users’ feedbacks and users’ usage is a must-do from any software organization, from IT departments to ISVs.

This post is organized as follows. The next part is about Growth Hacking as a control loop. I will first recall that growth hacking is about turning customer feedback into growth thanks to the (digital) product itself (it may be applied to other products that digital, but “hackings” says that it was designed for software defined products). The third part is about the true customer-centricity of Growth hacking and the importance of the “aha moment”, when the customer experiences the UVP (Unique Value Proposition). The last part talks about the dual relationship between teams and user communities. The product is used as a mediation between a product team and a group of communicating users organized into a community.  The product plays a key role for mediating between the two: it delivers new experiences and gather new feedbacks, but there is more than numbers to Growth Hacking.

A last caveat before jumping into our topic: this book is a “user manual” of Growth Hacking for practitioners. A summary does not really work and I will highlight a few key ideas and associated quotes, rather than attempting to cover the book’s material. I urge you to read the book, especially if you are in charge of a digital product or service and trying to grow its usage.


2. The Growth Hacking Control Loop



Growth hacking is about developing market and usage growth through the product itself and a control loop centered on customer feedback. I borrow the following definition from the beginning of the book : “Growth hacking allows companies to efficiently marry powerful data analysis and technical know-how with marketing savvy, to quickly devise more promising ways to fuel growth. By rapidly testing promising ideas and evaluating them according to objective metrics, growth hacking facilitates much quicker discovery of which ideas are valuable and which should be dismissed”. What sets the software world apart is that the product is the media. This is one of the key insights of Growth Hacking (and part of the reasons for the “hacking word”). Using the product as the media to communicate with users has many benefits: it is cheap – fixed cost that is good for scaling –; it is efficient (there is a “rich bag of tricks” that the book illustrates); it is efficient since it reaches 100% of users and it is precise since software analytics enables to know exactly what works and what does not. The authors summarize this as “enabling our users to grow the product for us.”

Growth Hacking may be implemented at all scales – from a startup to a large company – and for a large range of software-defined experience, from mass-market digital goodies such as mobile apps to B2B commercial software. This is repeated many times in the book: “Nor is it just a tool for entrepreneurs; in fact, it can be implemented just as effectively at a large established company as at a small fledgling start-up”.  As told in the introduction, this makes the book valuable for most companies since “software is eating the world”: “General Electric CEO Jeffrey Immelt recently said that “every industrial company will become a software company,” and the same can be said for consumer goods companies, media companies, financial services firms, and more”. What makes the value proposition of Hacking Growth so interesting is the success track with all the Silicon Valley companies that have used this approach: Twitter, Facebook, Pinterest, Uber, LinkedIn … and many more. Even though each story is different and each “growth hack” must be tuned to the specifics of each product, there is a common method: “It wasn’t the immaculate conception of a world-changing product nor any single insight, lucky break, or stroke of genius that rocketed these companies to success. In reality, their success was driven by the methodical, rapid-fire generation and testing of new ideas for product development and marketing, and the use of data on user behavior to find the winning ideas that drove growth”.

Growth Hacking control loop is built around measure – in a classical Plan-Do-Check-Act cycle. The first message here is that Growth Hacking is grounded in data. This is very much in the lean startup spirit: decisions are based on data, and the first step of the approach is to collect the relevant data. This is especially true for large companies, as is explained in the book with a number of examples: “
Recognizing that Walmart’s greatest asset is its data, Brian Monahan, the company’s former VP of marketing, pushed forward a unification of the company’s data platforms across all divisions, one that would allow all teams, from engineering, to merchandising, to marketing, and even external agencies and suppliers, to capitalize on the data generated and collected.” A growth hacking strategy starts with a data analytics strategy.  Taking decisions based on data requires quality (for precision) and quantity (for robustness). There is clearly a “data engineering” dimension to this first step: a “data integration architecture and platform” is often needed to start the journey. The story of Facebook is a good case in point : “ in January of 2009, they took the dramatic step of stopping all growth experiments and spending one full month on just the job of improving their data tracking, collection, and pooling. Naomi Gleit, the first product manager on Facebook’s growth team, recalls that “in 2008 we were flying blind when it came to optimizing growth.” This data fuels a PDCA cycle : “ The process is a continuous cycle comprising four key steps: (1) data analysis and insight gathering; (2) idea generation; (3) experiment prioritization; and (4) running the experiments, and then circles back to the analyze step to review results and decide the next steps.” Here we see the reference to the Lean approach, or to the TQM heritage of Edward Deming.

Growth hacking is a learning process with fast cycle time. Most growth hacks do not yield positive results, so it is critical to try as many as possible. At the end, success depends on “the rapid generation and testing of ideas, and the use of rigorous metrics to evaluate—and then act on—those results”. There is a lot of emphasis on the speed (of implementation) and the rythm (of experimentation). Many examples are given to show the importance of “fast tempo”: “Implementing a method I call high-tempo testing, we began evaluating the efficacy of our experiments almost in real time. Twice a week we’d look at the results of each new experiment, see what was working and what wasn’t, and use that data to decide what changes to test next”. It really boils down to the necessity to explore a large space of optimization, without knowing in advance what will work and what will not. The authors quote Alex Schultz from Facebook : “If you’re pushing code once every two weeks and your competitor is pushing code every week, just after two months that competitor will have done 10 times as many tests as you. That competitor will have learned 10 times, an order of magnitude more about their product [than you].” To achieve this fast cycle, one must obviously leverage agile method and continuous delivery, but one must also use simple metrics, with one goal at a time. A great part of the book deals with the “North Star” metric, the simple and unique KPI that drives a set of experiment: “The North Star should be the metric that most accurately captures the core value you create for your customers. To determine what that is you must ask yourself: Which of the variables in your growth equation best represents the delivery of that must-have experience you identified for your product?”.


3. Growth Hacking is intensely customer-centric


Growth Hacking starts when the product generates a “Aha moment” for the user. The “Aha moment” happens when the user experiences the promise that was made in the UVP. The product actually solves a pain point and the user gets it. Growth Hacking cannot work if the MVP is not a “minimum awesome product” that delivers the promise of a great UVP (redundant, since U means unique). As the authors say, “
no amount of marketing and advertising—no matter how clever—can make people love a substandard product”, hence “one of the cardinal rules of growth hacking is that you must not move into the high-tempo growth experimentation push until you know your product is must-have, why it’s must-have, and to whom it is a must-have: in other words, what is its core value, to which customers, and why”. The book logically refers to the Sean Ellis ratio, and the corresponding survey that is applied to customers to find out who would be truly annoyed if the product was discontinued. Sean Ellis data mining over a very large sample of startups shows that one must reach 40% for this ratio to say that consumers “love your product” and to start scaling successfully.

Getting to a product that may deliver a “Aha moment” is the goal of the MVP cycle. This is another topic, but the book gives a few pieces of sound advice anyway. The most salient one is to stick to the “minimum” of MVP and adding features instead of focusing on simplicity: “all product developers must be keenly aware of the danger of feature creep; that is, adding more and more features that do not truly create core value and that often make products cumbersome and confusing to use.”


The ultimate goal is to make one’s product a customer habit, up to an addictive one. This is a clear consequence of the growth model that is made famous by the Pirate Metrics, once the acquisition flows, retention becomes the heart of the battle. In our world of digital abundance, retention is only won when the product becomes a habit: “
The core mission for growth teams in retaining users who are in this midterm phase is to make using a product a habit; working to create such a sense of satisfaction from the product or service that over time”. The book is full of suggestions and insights to help the reader design a product that could become a habit. For instance, it leverages the “Hook Model” proposed by Nir Eyal.  The hook model has four parts, organized into a cycle: trigger, action, reward, investment. Many of the growth hacks follow this cycle to build up a habit. The book offers a step-by-step set of examples to build triggers (based on customer journeys), to develop all kinds of rewards and to foster customers’ investment into the experience (for instance through personalization and self-customization, leading to the feeling of ownership – a key component of emotional design). As the authors notice: “ some of the most habit-forming rewards are the intangible ones. There are many kinds of rewards to experiment with in this category. There are social rewards, such as Facebook’s “Like” feature, which has been a strong driver in making the posting of photos and comments habitual.”

The autors advocate about leveraging the growing wealth of knowledge that is produced by psychology and behavioral economics. Obviously, the work of Daniel Kahneman is quoted – cf. his great book “Thinking, Fast and Slow”,  but we could also think of Dan Ariely or Richard Thaler. There are many other interesting references to other frameworks to influence customer behavior, such as Robert Cialdini’s six principles. Among those principles, the principle of reciprocity may be used to drive revenue by asking customers to make small commitments, that create a solid bond that may be leveraged later on. The principle of social proof is based on research that shows that we tend to have more trust in things that are popular or endorsed by people that we trust. Another book that is quoted here is “The Art of Choosing” by Sheena Lyengar, I strongly recommend her video here. It is interesting to understand that choice has a cost, and that some of these choices should be avoided : “Debora Viana Thompson, Rebecca Hamilton, and Roland Rust, found that companies routinely hurt long-term retention by packing too many features into a product, explaining “that choosing the number of features that maximizes initial choice results in the inclusion of too many features, potentially decreasing customer lifetime value.


4. Growth Hacking : Teams meet Communities



Growth Hacking is a team sport. The importance of teams is a common thread throughout the book. These are teams in the sense of cross-functional, agile and empowered: “the creation of a cross-functional team, or a set of teams that break down the traditional silos of marketing and product development and combine talents”. Following the lean software principles, the cross-functional team is not a group of “siloed experts”, but T-shaped profiles that bring their own skills and talents but understand each other: “You need marketers who can appreciate what it takes to actually write software and you need data scientists who can really appreciate consumer insights and understand business problems”. I borrow yet another quote on the importance of cross-functionality, since this is a key idea to leverage effectively technology into innovation, in a larger context than growth hacking: “growth hacking is a team effort, that the greatest successes come from combining programming know-how with expertise in data analytics and strong marketing experience, and very few individuals are proficient in all of these skills”.          

Growth Hacking leverages communities of communicating users.  Growth Hacking is a story with three protagonists: the team, the product and a user community – the product as the mediation between the team and the community. The importance of user community is also superbly expressed by Guy Kawasaki … and Steve Jobs. The community is the preferred tool to get deep insights from users because analytics is not enough: “
Preexisting communities to target for insight into how to achieve the aha moment can also, of course, be identified digitally”. The combination of the “aha moment” that we saw in the previous section and the community of “evangelist” is what is needed to start the growth engine: “Once you have discovered a market of avid users and your aha moment—i.e., once product/market fit has been achieved—then you can begin to build systematically on that foundation to create a high-powered, high-tempo growth machine”. The community of active, engaged, communicating users is needed to get qualitative feedback in addition to the quantitative feedback that one gets with software analytics. This deeper insight is needed to truly understand customer behavior: “it’s crucial that you never assume why users are behaving as they are; rather, you’ve always got to study hard data about their behavior and then query them on the basis of observations you’ve made in order to focus your experimentation efforts most efficiently on changes that will have the greatest potential impact”.  This fine understanding of customer behavior is necessary to eradicate friction, which is a key goal of experience design, that is remove “any annoying hindrances that prevent someone from accomplishing the action they’re trying to complete”.

When striving for growth, in the same way than one should focus on a single metric, it is better to focus on a single – or very few - distribution channel. A large part of the book demonstrates this with illustrative examples. Focusing on a distribution channel helps to narrow the diversity of customer experience and makes the iterative optimization of Growth hacking better targeted and more efficient: “Marketers commonly make the mistake of believing that diversifying efforts across a wide variety of channels is best for growth. As a result, they spread resources too thin and don’t focus enough on optimizing one or a couple of the channels likely to be most effective”.  Growth Hacking is often associated with virality. Indeed, virality is a key growth engine and, as Seth Godin explained, virality must be designed as part of the product experience: “when you do focus on instrumenting virality, it’s important that you follow the same basic principle as for building your product—you’ve got to make the experience of sharing the product with others must-have—or at least as user friendly and delightful as possible”.  However, virality is only one aspect that may be tuned by the iterative Growth Hacking optimization cycle. Acquisition and Retention come first in the customer journey and should come first in the growth hacking process.
Bottom of Form

As explained in the introduction, a summary would not do justice to this book, which is full of great illustrative examples and relevant data points and metrics.  This is definitely useful for growing mobile applications: “
For example, for mobile notifications, opt-in rates range from 80 percent at the high end, for services like ride sharing, to 39 percent at the low end for news and media offerings, according to Kahuna, a mobile messaging company”.  Growth hacking is based on building growth models that are validated, tuned or invalidated with experience cycles. The book is filled with key ratios that are more than useful to start this modeling with default values that make sense. Here is another example that is truly valuable for anyone who tries to understand her or his application retention numbers: “According to data published by mobile intelligence company Quettra, most mobile apps, for example, retain just 10 percent of their audience after one month, while the best mobile apps retain more than 60 percent of their users one month after installation”. Focusing on measure is obviously the way to go, but making sense of measures requires modelling and this book is a great help to achieve this.


5. Conclusion





Growth Hacking is the third loop of the following representation of Lean Startup, which was developed and used at AXA’s digital agency.  As explained in the introduction, the goal of the first loop is to produce the proper UVP. No one should ever start developing a product or a service without a first-class UVP – As Ash Maurya said : “life is too short to build products that people will not use”. This is hard work, but many good guides are available, such as Ash Maurya’s Running Lean. Once the UVP is crafted, there are three huge and separate challenges:

  1. To build a MVP that delivers the promise of the UVP. This is actually incredibly difficult for large organizations: there is always a short cut that seems faster (and the pressure to deliver is huge) and there are too many stakeholders that will contribute to dilute the UVP. My personal experience, from the innovation lab to the hands of the customer, over the last 10 years, is that the UVP is lost 90% of the time. As was sated earlier, Growth Hacking starts when the “aha moment” is delivered, but this is not a zero-one situation and Growth Hacking may be used to debug or improve this “aha moment”.
  2. To craft and deliver the story of the UVP to the customer. I have been amazed during the same past 10 years at the number of times a great UVP was built into a product, a service or an app, and customers were simply not aware of it. Each time you would demonstrate the experience to a customer, you would see the “aha moment” and the smile, but 1-to-1 personal demo is not a scalable method. This book precisely addresses this problem. My experience over the years has been that the crafting of this story should be codesigned with the development team. Understanding the link between the pain points, the promise and the user stories is a key factor to build a consistent and delightful experience.
  3. To help the customer, once the UVP is “in the box” and once the customer has understood what it is, so that this experience may actually be found ! This is obviously a question of user experience design and usability, but it is a tough one. Here also, Growth Hacking is more than relevant: continuous iteration is the only way to solve this problem.






Sunday, June 18, 2017

Digital Experience Factories



 1. Introduction


I have left AXA a month ago to join Michelin. This is always a great moment to reflect on some of the ambitions of the previous past years. Today I will write about Digital Experience Factories. As AXA Group Head of Digital,  I have worked on setting up a Digital Experience Factory, a software development organization geared to produce digital artefacts and experience, following my previous work on lean software factories at Bouygues Telecom. The introduction of “experience” in the name is a way to emphasize the importance of customer experience in the digital world, but this has always been a key ambition of lean software factories as is shown on the illustration in the next section. The goal of this post is to re-formulate the key ideas and principles of a Digital Experience Factory, now that I have added a few more years of experience. It should be said that the concept of software factory is now well established and that most of what looked new in 2012 is mainstream in 2017.

I have had a long history of experience and interest with software factories, agile organizations and lean software, but I really started to put the pieces together in 2012. I defined the “Lean Software Factory” as the target for our Bouygues Telecom Internet product software division (Internet gateways and set-top boxes)  by merging principles from Agile (mostly SCRUM), Extreme programming and Lean, as explained in this previous post. The theory and the background references were rich, but we actually focused on four practices only:
  • Team Problem Solving
  •  Using visual management in a project room
  •  Reducing WIP through Kanban
  • Love your code (5S for the code, coding discipline, code review, gardening, etc.)

This vision has been presented at the Lean IT Summit in 2013 and you may find the slides here with both the general principles and the four practices.  Four the French readers, a simplified presentation was made at the 4th Lean IT Summit in Lyon (2014), with the attached slides.

I will start this post with an illustration that was produced in 2012, because I have reused it extensively at AXA in a digital factory context. Although the picture was produced to illustrate our ambition with set-top boxes, it is sufficiently user-centric and generic to be widely applicable. I was happily surprised to find it so relevant five years later in a different context. I will propose a short summary in the next section.

Section 3 will focus on the critical dependency between the innovation and the software factory. I have used the major part of the past three years at setting up lean startup innovation processes. I have already touched in a previous blogpost at the importance of the relationship between the innovation and software delivery processes, but I would like to emphasize the co-dependance of these two processes which I have labelled “from customer to code” (lean startup) and “from code to customer” (devops). In the digital world (more generally in the modern complex world), “the strategy is the execution” (i.e., you are what you do).

The last section will talk about the role of digital experience factories in the world of exponential information systems.  Since “software is eating the world”, it creeps precisely everywhere in companies’ businesses, inside the company (each piece of equipment in a factory or human collaboration is becoming “smart or augmented”) and outside (customers’ digital lives or business partners). Software factories have a role to play in a larger software ecosystem, with a multiplicity of roles and stakeholders.


2. Digital Experience Factory Blueprint


The following picture is an illustration of a Digital Experience Factory – as well as a lean software factory. Although it is pretty old (in the digital time), I have found that it is still a good blue print for setting up a software factory in the digital world.



This picture is pretty much self-explanatory but I would like to point out a few things, i.e., explain the choice of a few keywords. To keep things short, let’s define the seven foundations of the Digital Experience Factory:

  1. The input for the factory is made of “pain points” & “user stories”. No one should be surprised to see user stories for an agile software shop, but I have found that they should not be separated from the “original paint points” which they are derived from. Our practice at AXA has been to build “UVP trees”, which a graphical representation that links the pain points, the UVP (unique value proposition) and the user stories. Sharing UVP with everyone in the software shop improves considerably the quality of the code (from a customer experience point of view). More generally, a key principle of a lean organization is to make sure that “the customer is represented on the production floor” and that customer testimonies – including pain points – are available (visually) to all actors of the process (not just the designers or product marketers).
  2. The output of any software development is end-user experience and is measured with user satisfaction. Customer satisfaction is the “true north” of any lean (in the Toyota Way sense) organization. Because customer satisfaction is complex (in a systemic sense), it requires an incremental approach and a feedback loop.
  3. CICD (Continuous Integration and Continuous Delivery) is the crown jewel of modern software organization. This is where the huge productivity gap resides, but this also requires significant efforts to setup. I refer you to the great Octo book, the Web Giants, which I have used extensively to evangelize and promote change in the past 5 years. CICD starts with Continuous Build and Integration and continued with Continuous Delivery using DevOps practices. This is probably the part of the picture that has evolved the most in the past 5 years since DevOps is now a mainstream critical recommendation.
  4. Test-driven development is also a critical aspect of a digital experience factory because it fuels the CICD ambition (automated tests and automated delivery go hand in hand), but also because it helps to produce higher quality code with less stress, hence more pleasure. I urge you to read Rich Sheridan wonderful book “Joy, Inc” to understand the importance of culture and pride in software development. This obviously goes back to the three tenets of self-motivation according to Daniel Pink: autonomy, mastery and purpose.
  5. Visual Management & Kanban are the most visible parts that are borrowed from the lean management principles in a Digital Experience Factory. There are two plagues in most software organizations:   rework (and its cousin, dead code) and waiting (people waiting for one another). Any software development audit that I have had to undergo in my past 15 years of professional experience has found these two issues. Visual Management, in general, and Kanban, in particular, is the best way to tackle these two problems.
  6.  “Source code is king” in a digital software factory. The new world of software is characterized by the increased rate of change and innovation. This creates two new requirements : (a) one must love one’s source code because it will be required to be looked at and changed constantly  (b) one must reuse as much existing code as possible, hence the importance of leveraging open source as a code feed (cf. the illustration).
  7. Synchronized team work : the digital experience factory is organized into squads, autonomous cross-functional teams. There are at least three important ideas here. First, Squads are cross-functional teams where all necessary skills are working together. Second, synchronized work means working together at the same time on the same problem. This creates an environment where everyone “understands a little bit of everything” which reduces informational friction considerably. Last, the squad is autonomous, both for speed and motivation.




3. Innovation Factories and Learning Loop



The following picture is borrowed from a presentation that I made at XEBICON 2015. It is the best illustration that I have of the interdependence of the innovation process and the software delivery process, and it illustrates what I have been attempting to build at AXA during the past few years.


The key point of this picture is that, although there are two processes, there is only one team and one product that is being built. Other said, these are the same people who participate to the two processes. The capability that the first process it aiming to build is to produce digital artefacts (mobile or web apps, connected object, cloud service, etc. – i.e., code) from listening to, and observing, the customer. The capability of the second process is being able to deliver to customers – at scale – a product/ service from the original code that is produced by the developer in a continuous, high frequency and high-quality manner. What I have learned over the years is that these two processes are very dependent on each other, which is, once more, a lesson from the Web Giants ! It is very difficult to run a lean software factory without the true customer centricity of a lean startup approach (cf. the importance of customer pain points, satisfaction, user stories and testimonies in the previous section). It is equally difficult to implement a lean startup approach without the performance of a great Devops software factory : the iterative process requires the high frequency of delivery, customer satisfaction demands high quality software with high performance and as few defects as possible.


As stated earlier, strategy and execution are merged in the digital world : a strategy only becomes real when it has been executed  and adapted to the “real-time” environment, and execution requires to grow and adapt the strategy continuously. Success becomes a function of the “digital situation potential”, which is a combination of skills, low technical debt and a flexible open architecture. The following illustration is borrowed from the same blog post. It shows the importance of separating different time scales:
  • T0: The immediate time scale of customer satisfaction: delivering what is requested. This is the takt time of the factory process.
  • T1: The “mid-term” time of continuous improvement. This is the kaizen time, which is more uncertain since some problems take longer to solve
  • T2: The “long-term” time of learning. In a complex word, most learning is performed “by doing”. Training happens “on the gemba”, through practice.



This picture is also a great illustration of how the double benefits of the digital experience factory agile and lean roots. Lean and Agile reinforce each other. Agile software development practices are mostly T0 (and some T1 with reflection practices) while lean emphasizes T1 (kaizen) and T2 (kaizen again ! plus dojo practices). Agile and SCRUM are born as “project development methods” whereas lean software programming is geared towards product development. I have covered this topic with more detail in my post about Lean and Architecture.  Long-term sustainable development requires architecture and it is somehow not easy to see where architecture fits in the agile framework, while architecture is a cornerstone for lean sustainable development. I also refer you to the book :  Lean Architecture – for Agile Software Development”  from James O. Coplien & Gertrud Bjørnvig.

A key piece of the Digital Experience Factory illustration is the feedback loop from customer experience (i.e., the satisfaction or the absence of satisfaction / the usage or the absence of usage). I have formalized the “Customer Feedback learning Loop” (CFLL) over the years, and our experience at AXA has helped a lot to setup best practices that may be easily reproduced.
  • CFLL is practiced with three “channels”: implicit, explicit and social.  Implicit listening means using the power of imbedded analytics to track the effective usage of customers. Explicit is “active listening” of users to hear about their usage and satisfaction. Explicit means that we look for verbatim (e.g., in the stores), testimonies from users (through interviews). Active means that this is a conversation, we may ask questions or answer to customers. Social listening requires setting communities/digital tools so that users may act as a group. Experience over the past 15 years has shown that the dynamics of feedback is very different with a group, which feels more empowered, than with individuals
  •  CFLL is managed as any quality improvement loops, using a “Toyota-style A3” which supports a PDCA (Plan-Do-Check-Act) approach. Looking for root causes using the “5 whys”, setting up kaizens with the whole team, and careful formulation of assumptions is critical, since digital troubleshooting is hard and full of counter-intuitive surprises.
  •  CFLL is part of the Growth Hacking toolbox and also leverages “source code as a marketing tool”, that is making the digital product a marketing and sales channel for itself.
  • Because social tools are useless without a community, a key task of the CFLL approach is to grow and nurture a community of engaged users. This is very well explained by Guy Kawasaki in his book “The Art of the Start” :  Success comes from fast iterations applied to a rich feedback ; there is no better way to get this rich feedback than building an “ambassador communities”.



4. Software is eating the world


I will conclude this post by stepping back and discussing about the role of the software factory in the larger software ecosystem that companies need to be part of, since “software is eating the world”. A first logical consequence of Marc Andreessen observation is that software is everywhere in the companies, with a much larger footprint than our “traditional information systems”. I use the world “software” because “digital” is ambiguous. It its broad sense, everything that using bits, digital information, is part of the “digital world”, hence software is part of it. In a narrower sense, which is used many companies, “digital” is what matters to customer, the impact of software, computers, bits … in their daily lives. Many company separate digital and IT because they use a narrower definition of digital (with the broader sense, smart factories, IOT, computer-mediated communication, information systems, web, mobile and cloud services, etc. are all part of the digital scope). To avoid that confusion, I use the word “software” as the common root for customer digital, information systems, Internet of Things, smart control of machines, and digital communication. This helps to understand that no software factory (in the digital, IS or other organizations) is an island.  It is part of multiple ecosystems, internally within the company and externally with other partners and stakeholders. In a world which is dominated by platforms,  a software factory is not only a process that produces code, it is also a host of a software environment (usually centered around a platform) and an ecosystem player through API (Application Programming Interfaces).  This also means that software factories are de facto partners with the company information systems, while at the same time it is clear that the footprint of software in companies is growing faster than their information systems. To reuse an old term from the 2000s, “shadow IT” will grow and not shrink in the future. 

There is indeed a common software ecosystem – of data models, API, architecture patterns – for each company that requires careful thinking and management, which comes from a global viewpoint. Platform engineering demands a common data exchange model (not necessarily a unique data model) as well as common engineering practices (know-how & culture) for API. In other words, “software is eating the world” but it will eat better and faster the world of your own business if you care to manage this emergent process. This is a great opportunity for information systems (IS) organization to play a “backbone role” for the various software ecosystems. Many of these software ecosystem issues are technical (software hosting and security constraints) and architectural issues (event-driven architecture, distributed data architecture) which require skills and experience that are part of information systems DNA. On the other hand, the loose coupling of platforms that are produced by autonomous teams may be a “new art” for the more traditional IS organizations. In the digital world, the platform is the team and the team is the platform: the platform is a live object that evolves continuously to adapt to its environment. A software platform is not something that you buy, not even something that you build, but something that you grow.

 I will conclude with a simple but powerful idea: Digital Experience Factories are technology accelerators, i.e. open ports for a companies to leverage the continuous flow of exponential innovation. What I mean is that Digital factories are part of exponential information systems, they make the edge (the border) of the information systems that is in contact with consumers, business partners, and innovative players. In a fast-evolving world, most companies are looking for ways to become “future-proof”. The architecture of exponential information systems draws from biology with a core that evolves slower while the frontier (membrane) evolves at a faster rate from the contact with the outside environment. Digital Factories are part of this “Fast IT” with a clear opportunity to leverage the flow of new technologies such as Artificial Intelligence, Machine Learning or Natural Language Processing. As I explained in a previous post, there are four requirements to harness these new software techniques:
  • Access to data (intelligent software drinks huge amounts of multi-sourced data)
  • Use of modern software stacks (i.e., leverage latest open sources libraries & APIs
  • Autonomous cross-functional teams
  • Lab culture (fact-based decision and iterations and failure are welcome)

One can recognize in this list the foundations of the Digital Experience Factory as explained in the second section :)





 
Technorati Profile