Agile, Startups

Proof of Concept? MVP? Just tell me when it’s done!

The meeting between iterative product development and a company used to approaching product development through the project-lens can be quite harsh.

On one hand, you have set budgets and revenue targets. The project deliveries have been planned out in detail for the coming months, quarters or even years, with a chain of dependencies for the rest of the year.

On the other hand, you need to follow up deliveries and make day-to-day decisions that affect the scope and the end product drastically in a true agile manner.

All the while nobody can give an answer to whether you’ll hit your targets or not. And you, as a stakeholder or project owner, just want to know when it will be done!

Here’s the deal…

There are a few things to note when moving into this world of digitalising organisations and iterative product development.

  • Agile™️ doesn’t mean faster or cheaper.
  • You decide when it’s done.
  • Product development is hard.

If you’re willing to take my word for it then you can stop reading now. Otherwise, please continue…

Agile / DevOps / Lean doesn’t mean faster, cheaper or easier

Digitisation has been sold into organisations as the “way to go” and alongside this the notion of some form of agile software development. The implication (or outright promise) is that this form of development will be faster, cheaper or both. There are no guarantees of this.

Instead, what these practices mean is that you are able to test your assumptions in a more iterative manner. This means you can create just enough of a product that will allow a customer to use it and give you feedback before your next iteration. So, in this sense, it’s a lot cheaper to verify you are on the right path, and the cost of course-correcting is a lower than if this was a project going over several months or years.

Working this way is more demanding of your time, as you are now part of the team that builds and discovers the product — you need to be available on a more ad-hoc schedule. There are more small follow-up meetings and constant changes to priorities based on customer feedback, or new opportunities. Working like this is engaging and fun, but it can also be draining. Especially if you’re used to the more traditional “ordering” of software through larger “waterfall” -projects.

Product Development is Hard

The hardest part of building a software product is knowing what to build. You may have an idea of what you want to create, but will that actually meet people’s needs? Saying you need an app or a service doesn’t instantly make it something that people want to use. The only way to find the market-fit is to test it out with real customers and users. This is what an iterative development methodology offers — the chance to test assumptions before you run out of budget (money, time, goodwill, etc).

Gone are the days where business and in-house customers accepted sub-par products to be able to get their work done. Consumers are used to sleek, intuitive apps on the web and their devices. There’s no magic switch that causes these same people to lower the bar of what they expect when they enter their work setting.

This expectation of quality becomes a challenge for businesses wanting to raise the bar. As the quality of the products improves, so does the need to build the right thing. It is crucial to verify whether the pain you are trying to address is one the people using your product actually feel, and want dealt with.

To keep up with this pace means focusing more on product development as a core discipline, instead of something to be outsourced or managed from afar.

You decide when it’s done.

The dirty secret is that “it” is never really done — the elusive product remains a moving target. Getting something out the door is just the first step. Instead, the focus should be:

  • When is the product good enough to be valuable to the people using it?
  • How much are you willing to spend to find out how close you are to fulfilling those needs?
  • How do you know the product is actually attending to the needs and delivering value?

With an iterative process, you have the opportunity to approach answering these questions and respond by changing the direction of your product. But the only way I’ve found to get real feedback is to give full slices of functionality in front of real users.

Sketches, prototypes, proofs of concepts and minimum viable products are all viable approaches to elicit feedback — the earlier the better. Pick your flavour, be harsh with the scope, and get a working product out there!

Finally

Organisations’ need for fixed budgets, scopes and roadmaps can hinder you from realising the tantalising promise of value in a truly iterative product development cycle. That value is the agility to be able to respond to changing needs, and new opportunities.

Embrace experimentation through continuous feedback cycles and adjust the reality of where you are with a product based on them. Based on these feedback cycles you’ll know when you’re done.

Clap ? or follow Dolittle to read more about how we believe in enabling others to create products that help users feel like superheroes.

Cover Photo byJosé Alejandro Cuffia on Unsplash


This post appeared originally on the Dolittle blog

Agile, General

“just add an if”

You’re talking about a new feature that’s being planned and prioritized to the dev-team. It’s straight-forward enough, but you sense that it’s latching on yet another feature to an existing long chain of functionality. The team has some reservations to expanding the feature chain even more before doing some adjustments to how it’s been architected to keep this maintainable. That’s when you hear from the product owner: “Just add an if…”. Continue Reading

Agile, Craftsmanship

Long live Code Reviews! Code Reviews are dead!

Let me introduce you to Malcolm. He’s my imaginary developer-friend currently working at Mega Enterprise Inc Ltd Corp. He’s been butting heads with the lead developer, Jack,  for a while now. They don’t seem to be seeing eye to eye on a feature that Malcolm implemented. You see, Jack doesn’t like how Malcolm writes his code. Formatting is wrong and he uses way too long variable names, and he doesn’t write a single comment and…(list goes on)! Jack hates reviewing Malcolms code. Malcolm usually gets his code back from Jack, with a long list of TODOs. So Malcolm goes off to re-do most of his work just to give it back to Jack…When Jack’s finally happy with the code; It adheres to his preferred coding style and uses the correct enterprise patterns that have been decided upon. He allows it through the magic gates to master. Continue Reading

Agile, Developer growth

Trusting in the Mob – A story of bringing distributed team members closer

Working in a distributed team isn’t easy, especially when members are spread across 4 locations. I was recently part of a team that was doing pretty well, but wasn’t functioning as a cohesive unit. There seemed to be hesitance towards pair-programming sessions, even though doing quick Skype calls seemed to be fine. We were relatively open during retrospectives, but were missing out on the deep conversations.

I had a feeling this was a trust issue, and that spending more time together could help. Sitting in an online meeting doing team-building exercises didn’t seem like the best approach, which is when I stumbled over Mob Programming as a way to both get work done, and build up the team’s collective trust and understanding. Continue Reading

Agile

Accepting that every team member is doing the best job they can

Many software development teams have a process including retrospective meetings. An opportunity for the team to look back at a period of time and assess how it has functioned. It’s often connected to the Scrum, but you don’t need to be adhering to any process / approach to see the value of having retrospective meetings. The goal of the retrospective is learning. What worked? What didn’t work? How can we improve something that’s broken? Should we continue with something that’s working?

Another aspect of the retrospective is that it’s meant to be a safe place for team members to speak their minds. The idea being that given a safe place, a team can figure out its own problems and possibly even solutions.

To create that safe place there needs to be trust. Enough trust so that team members can be candid with each other about issues that arise while working together. Enough trust that allows the team members to be vulnerable, and know that they won’t be judged. Where blame isn’t handed out, but rather bonds created and learnings are formed.

But how do we create a space in the busy life of a software development team, where deadlines and bugs are commonplace and there’s often a pressure to deliver something that will create value? Continue Reading

Agile

Presenting software to non-technical users – 8 ways to make your product demo shine

We’re sometimes placed in situations where we need to present our software to stakeholders, business owners or end users. These users may or may not be technical, but they will most likely be the other side of the user interface you are creating. They are the reason you create software and are genuinely interested in the end result. In recent years, with Agile and Scrum, these presentations tend to take place more often and you’re in the limelight presenting the latest and greatest. Many years of honing our skills as software developers have all but prepared us for this challenge, and we may end up getting a response from the attendees along the lines of this:

Photo credit: markhillary via VisualHunt.com / CC BY
No, we’re not impressing anyone –  Photo credit: markhillary via VisualHunt.com / CC BY

Too much uptight focus on technical details, digging deep into issues that nobody cares about, discussing the framework, library or platform chosen to solve a particular problem leaves you attendees bored, confused and sometimes feeling dumb since they haven’t got the faintest idea what you’re talking about. This leads to frustration, arguments, cold-fronts or just a general feeling of “meh”, where developers, stakeholders and users just don’t get the value out of this important meeting arena they could.

So what’s a developer to do? Here are some tips and thoughts for preparing for, presenting and participating in more technical presentations.

Continue Reading