How product design works when you ‘think big and release small’
Or, the special seasoning we add to the bread and butter of agile
As a product designer at NerdWallet, my job is to help people achieve their short- and long-term financial goals — and, at the same time, to help my product and business partners meet business goals. It’s a lot to juggle, but it’s the best kind of challenge.
The good news is designers don’t have to do it all at once. At NerdWallet, we embrace the idea of “thinking big and releasing small.” Like many software companies, we follow the agile framework, which allows us to release features and improvements to users in small chunks. But the “think big” part is a layer we put on top of agile. It means we use all of our critical thinking and problem-solving methods to address people’s needs, wants, and frustrations — and then smash those big ideas into smaller bits that allow for learning.
Thinking big and releasing small is about compounding value for people over time. We have a big vision in mind — but we don’t wait to get every piece of that vision finalized before we start getting it into users’ hands. Sometimes, we can’t get to the big vision right away because it’d take a lot more design work than we’ve scoped. Other times, it’s because our big idea has technical constraints that we’re not ready to address. And often, the big idea is exciting but not yet validated by users.
But that doesn’t mean we abandon the big idea. Instead, we break it into smaller releases, which equip our team with quicker feedback loops and set the conditions for more intentional iterations. Releasing small allows us to reach people faster and therefore learn faster, sending our team into our next product development cycle sooner. If we learn that we are on the right track to solving the problem for the user, we can then iterate into the big idea — and we can be sure that our small releases build upon each other and don’t create a confusing Frankenstein experience down the line.
Here’s how it works:
Thinking big
Thinking big can happen at any phase of the end-to-end design process, but we typically use it at the top of an initiative or project. It requires deep thought about a problem, casting a wide net, and generating ideas that might help us accomplish our goal.
The product team must align on the problem we hope to solve to think big. We work with our user experience research partners and other stakeholders to take stock of what we know because what we know will inform our brainstorming — or highlight the need for more discovery. Once we know enough about the people we aim to serve and have defined a reasonable scope, we start brainstorming without guardrails or restrictions.
Thinking big doesn’t have to mean we’re solving a huge, gnarly problem — it can be a part of more everyday design decisions too. It just means we’re thinking beyond the immediate project on our plates.
Shipping small
After our big thinking, we start to narrow down: How can we take this idea and slice it up so that we have one single concept or hypothesis to test? We focus on small tests that enable agility, fast iterations, and shorter feedback loops.
Sometimes, small releases are relatively minor, noncontroversial changes that buy time for more considerable discovery work in parallel. Other times, they’re test balloons to allow us to gather early data on an idea before fully committing. No matter what, these small releases are the bread and butter of the agile framework — but we add the special seasoning of thinking big ahead of time. Because we’ve thought through the larger vision, we can work toward a future where all the small pieces will come together.
Putting it all together
A great example of “thinking big and releasing small” is my product team's recent work on an experience that helps people start investing. There were some large, structural, but less validated ideas we had our eyes on — and there were also some small changes we knew could create quick wins. So instead of putting all our effort into scoping the big picture, we released small changes first to create a foundation and start learning. First, we updated the typography to align with our current guidelines. At the same time, we changed a few components on the screen to accommodate the new type style and set us up for future iterations. Along the way, we made sure to think about the overall user experience — present and future — to avoid introducing confusion or other pain points down the line.
Another time, my pod wanted to make a small change to another experience we own — this time, a mortgage calculator. We could’ve jumped in and made those changes within the agile framework — shipping small and learning along the way. But we paused before we started and thought big — gathering data from other pods. It turns out many other calculators on NerdWallet are powered by the same backend app, and if we made changes to our calculator, it’d affect other calculators too. Making sure we thought beyond our own roadmap and stayed true to the bigger picture saved us a lot of headaches and our friends on other product teams.
In conclusion…
Thinking big is about changing the world. Releasing small is about compounding this value and incrementally improving your product or service. Using these ideas in tandem helps us gravitate toward faster iterations and learning and helps us keep our eye on the prize and avoid creating a fragmented experience. Instead, we monitor the incremental releases, learn what is working, find new opportunities, and repeat. It’s an efficient way to work and an efficient way to impact the lives of those you serve — in short, the ultimate win-win.
