Minimum Unviable Product

Thinking Small to Move Fast With Quality

About this Presentation

  • Sort of a post-mortem
  • But not really because we are going to plan too
  • This is based on a real project

Problem Statement

We need you to build a URL shortener. We're going to use this with our text messaging system to send short links to people. It needs to support multiple domains, some internal and some external.

Redirects

  • Short URL -> Long Url
  • Doesn't exist -> 404 external
  • Doesn't exist -> Redirect to UI internal

Create

  • Can create named URLs
  • Can generate short URLs
  • Can create via API
  • Can create via UI

Update

  • Change the long URL of a short URL
  • Can update via API
  • Can update via UI

Delete

  • Stops redirecting
  • Maintains history after delete
  • Can delete via API
  • Can delete via UI

Query

  • View short URL details (UI)
  • Retrieve short URL details (api)

Multiple Domains

  • Some internal facing (s.f, air/)
  • Some external facing (st8.farm)
  • URLs are unique to the domain

Product Features

  • Redirect
  • 404
  • Go to UI
  • Create named API
  • Created generated API
  • Create UI
  • Update API
  • Update UI
  • Soft Delete API
  • Soft Delete UI
  • Search UI
  • Internal Domains
  • External Domains
  • Query UI
  • Query API

Product Dependencies

Goals

  • Identify Dependencies Between Features
  • Create a Rough Ordering

Dev Dependencies

Goals

  • Identify Dev Dependencies
  • Put them on our plan before the first time they are needed

Design Considerations

  • Multiple Domains

Create Rough Sprints

Suggestions

  • Aim to deliver value every sprint
  • Don't plan to tackle more than one dev dependency in a sprint
  • Group a dev dependency with product functionality
  • Keep your sprints focused, you should be able to name your sprint like a Friends episode

Parallel Work Streams

What is the MVP?

Create Sprint 1 Stories

404 Story

Given a short URL that doesn't exist

And an external domain

When I navigate to the short URL

Then I should get a 404

Hard Mode

State Farm's

Release Process

  • ~18 month release cycle
  • Minimum 2 months system test
  • Minimum of 1 month in performance test
  • Minimum 2 months implementation test
  • Minimum 3 months from the completion of integration test to production
  • Builds must be certified by QA before being allowed into the next environment

Process Restrictions

  • Every release must impact users
  • Prove that every known function of the application works exactly as intended in every environment (dev, system, pre-production, production)
  • 100% automated regression tests for all bugs
  • Automate deployment to each environment
  • Automate build certification
  • Beyond dev must use real dependencies (db, service, logging, etc.)

Sure, but are there any hard problems?

Definition of Done

  • 100% mutation test coverage (code coverage is a pointless metric)
  • Every path must have an integration test
  • Integration tests must be repeatable
  • Integration tests must have net 0 impact (everything created by the test is cleaned up)
  • Integration tests must have passed in all environments (including production)

Code Coverage





@Test
public void testMyMethod() {
    myObject.myMethod(null, null, null);
}

Mutation Testing


@Implementation
public int inRange(int min, int max, int valueToTest) {
    return valueToTest >= min && valueToTest <= max;
}


@Test
public void testMyMethod() {
    myObject.myMethod(null, null, null);
}

/* Failed mutation 1 -> 
    changing `valueToTest >= min` to `valueToTest < min` did not cause test to fail
*/

/* Failed mutation 2 -> 
    changing `valueToTest <= max` to `valueToTest > max` did not cause test to fail
*/

/* Failed mutation 3 ->
    changing `valueToTest >= min && valueToTest <= max` to
    `valueToTest >= min NAND valueToTest <= max` did not cause the test to fail
/*

Sprint Plan V2

Wrap Up

  • Deliver Every Sprint - any value is enough
  • Stay Focused
  • Bundle Dev Deps with Product Functionality
Made with Slides.com