Thinking back to when I ran a web agency and made software for other people, I realize how insane it was for clients to expect their software to be perfect as soon as it launched.
Sadly, insane client thinking is not entirely their own fault because many agencies (mine included) encourage this type of thinking. Consider this common scenario:
- Client has brilliant idea for an application that does X.
- Unable to afford a full time team, the client decides to outsource to a design agency.
- The agency is happy to receive the call and sits down to discuss this brilliant idea.
- Throughout the course of conversation, the agency convinces the client to hire them to build the product.
- The client is happy because s/he believes after paying $X s/he will get a fully realized product that will generate revenue and change the world.
- That doesn’t happen.
Here’s what really happens:
- Instead, the client reviews the software and suddenly begins thinking about all the little ways to make it better (usually without user testing).
- The client comes back with a massive list of changes — some are bugs, most aren’t, and others are subjective.
- The agency goes mad trying to manage the client’s expectations, pushing back on things that are out-of-scope.
- The client is fed up because the end product doesn’t live up to his/her wild imaginings and feels s/he overpaid.
- The software finally launches (over-budget), and once the client gets people using it, the real bug reports start coming.
Have you ever been in that situation? I know I have. It felt like there was no way to win - you either have to charge what a project is really worth and give your client sticker shock, or you meet a client’s budget and lose money, or charge them more afterwards. None of these scenarios is pleasant.
Sure, there are things you can do to minimize these problems but if your client has the wrong expectation about the end product, you’re never going to please him.
Here are 5 harsh truths every client needs to realize about their pet project (and it’s your job to tell them):
1. Your idea probably isn’t very good
I could write a volume about all the lousy ideas potential clients came to me with over the years. An app for organizing your junk mail. A matchmaking site for platonic relationships. Just awful, awful ideas. Most of these clients were nice people with bad ideas they thought could make money.
What many clients don’t realize is all of the up front work it takes to validate an idea before you start spending money on it. You have to define your target market and competition (hint: if there’s no competition there’s a good reason for it). You have to interview potential users of the product and get their take. This is how successful startups are successful.
It’s hard when you’re the agency because you don’t want to turn down work and you don’t want to tell someone their dream is stupid. But you also have to believe in what you’re doing and set realistic expectations, even if you’re just a hired gun.
2. The first version is a learning tool for the real thing
Clients need to understand that the first launch won’t be a fully realized product yet. As hard as anyone tries to find all the holes during the design and testing phases, the product is still not going to be close to finished.
Even if you perform user testing before building out the product, new holes will be found once people start actually using it. You can’t account for every possible use-case, and people will unwittingly find ways to break the software. It’s not reasonable for clients to blame the agency for this so if you warn them upfront, you’ll lessen the chance for hard feelings.
You have to build the software to learn what to build. You may even need to re-write it from the ground up once you figure out what the client’s market really wants and will pay for. It sucks, but it’s not the agency’s fault, it’s just part of the process.
3. Design and testing are not phases
Project managers wish badly they could fit design in at the beginning and testing at the end of their gantt charts, with a big meaty chunk for development in the middle where the “real” work is done.
The reality? Startups are continually designing and testing their software before, during, and after development of each particular feature. This takes a lot of time. Is your client prepared for this? Is your team and your business?
To make matters more difficult, your team has to design within a box because everything must fit neatly into a time sheet. When the time runs out of the design budget, and the client is relatively happy, you have to move on even if a few more iterations would have landed a vastly better and more successful product.
The same goes for testing - there are multiple kinds of testing and all have their distinct purposes:
- User testing is for finding usability holes or issues with the “flow”.
- QA testing is for finding bugs, simple as that.
- Beta testing is for learning from the target market whether or not there is a business (usually the answer is no and you’ve got more work to do).
In a startup, this kind of testing is happening all the time at every phase of a project. Agencies often aren’t afforded this luxury.
4. Yes, there will always be bugs. No, fixing them is not free
In an ideal world, bugs wouldn’t exist. No one likes them. Developers certainly don’t - they are the ones who have to fix them after all.
But they do exist, and any time you are building software that human beings will use, bugs will be found. That doesn’t mean your agency isn’t skilled, nor does it mean anyone was sloppy. No one screwed up, it’s all just part of the process.
There are ways to minimize bugs, but it comes with caveats that the client must understand;
1) They can choose to build fewer features (read: less complexity) into your first version, or
2) They can extend the timeline and budget to accommodate for frequent QA test cycles and generous time for fixes and regression testing (i.e.: testing it again to make sure other stuff didn’t break in the process)
Generally, that’s not what the client will want to hear.
Unfortunately, it’s the truth. Clients have to pay for testing and bug fixes because it’s literally impossible to build software perfectly in one fell swoop. Getting upset or trying to punish the agency by holding back payment doesn’t help anyone. Clients need to consider the costs at the beginning and budget accordingly and while you might not be able to fully convince them of the importance of this, you can at least advise them appropriately.
5. If they think this is expensive, imagine paying your insurance and vacation time
Clients need to be nicely reminded that they hired an agency to build their product because they couldn’t do it themselves nor could they afford to hire their own team of employees.
If everyone with an idea and a chunk of change to throw at an agency could taste instant success upon launch, there would be a lot more successful startups out there.
If a client believes their product idea will solve a market pain, then they should go all in or stay home. If it works, they’re likely going to need to eventually hire an in-house team, possibly even raise investment capital.
For a great read, check out Alex Turnbulls post about his decision to hire an agency to build his beta product before he raised investment dollars and hired a team.
“As I rewrote my pros-and-cons list for the sixth or seventh time, I had a sobering realization… Four months from now, I could have a living, breathing product in the market that would let me collect user feedback, get validation and push this business forward. Or, I could still potentially be sitting here with nothing. I signed the contract that afternoon.”
Like Alex acknowledges, yes an agency will need to bill a client to keep their lights on. Expecting an agency to care about a product as much as the client does is like expecting a babysitter to love your child as much as you do.
But his decision to get his product out the door and in users hands, gave him something to show investors, and it took him another year or so to build a team and find product/market fit. I believe this is the best reason for clients to hire an agency.
Building software is hard no matter who you are, but it’s even more difficult if you’re working for clients who have unrealistic expectations. Hopefully some of these harsh truths can be shared (tactfully) with them so everyone can go into the business relationship with eyes wide open.