Managing web design projects where you collaborate with a developer is something I’ve seen a lot of questions on in the communities I’m a part of. No matter who you’re bringing into your process, having someone else to manage is a new way of thinking. And when you’re outsourcing something as important as development, it can feel a little intimidating.
Even designers who are seasoned pros when it comes to collaborating with a developer may not be doing things in the best way possible.
The goal is for you to manage the project in a way that keeps things fair, safe, and clear for everybody. Today we’ll touch on 3 essentials of managing web design projects with a developer.
To learn more about working with a developer, unlock the ultimate checklist to go from hours of code to development-free design projects. Click the button below to get started!
Owning the title of “project manager”
Before we dive into the 4 essentials, let’s touch on why you even need to worry about project management in the first place.
You might wonder why the developer’s job can’t just be completely separate from yours. You could then create your design, get approval from the client, get your final payment, and then let the client worry about working with the developer.
There are a few issues with this.
Downsides of choosing not to be the project manager
First, you have no control over the final outcome of the website when things are done this way. Without your creative direction and stamp of approval, the website may end up looking nothing like what you’d imagined, which may reflect poorly on your work in the end.
Second, it’s a much better client experience when you can take care of the entire website. Clients don’t go looking for someone to design a website expecting that all they’ll get are “pictures” of what it will look like. They expect a completed and functional website by the time the project is finished.
And right along with that, designers who are willing to manage the website from start to finish will stand out to the client in the proposal process since dealing with one person sounds a whole lot easier than two.
Your job as project manager
Your job as the project manager is to work with your client to complete the design, work with your developer to bring the design to life, and make sure the project launches and looks just like you’d planned.
This sounds like a lot of pressure and extra work, but it’s not once you have a good system in place (and a reliable developer to work with).
Now that you know why it’s important to take on the project manager role, let’s move on to those 3 essentials!
1. Cover the developer’s terms in your client contract
The most common contract setup when working with a developer is:
- You have a contract with your client that covers the full project
- Your developer has a contract with you
Now, of course, you also have the choice of sending a contract to the developer, but it’s something that’s not done quite as often.
This setup is nice and easy for all problems involved, but it’s possible that you could leave a few holes in protecting yourself.
The most common problem with contract setup
Consider this scenario:
Your developer’s contract states that if any materials (mockups, text content, images, etc.) are late that there’s a $150 late fee for the first three days and after that, the project will be rescheduled for a $500 rescheduling fee.
In most projects, that would never be a problem. But what if you end up with a client who doesn’t seem concerned with sticking to due dates? That client fails to give you the information you need in time to have everything ready for the developer and you end up being a week late delivering content.
Since your contract didn’t cover those terms, you are now responsible for paying your developer $650.
No. fun. Right?
You never want to be stuck with consequences of actions that are not your own. Especially because you always do whatever you can to keep a project on track and everyone involved happy.
How to protect yourself with your contract
To protect yourself, make sure all of your developer’s terms are covered in your own contract.
In the above scenario, you’d want to ensure that your client would be responsible for the $150 late fee as well as the rescheduling fee (plus any fees of your own).
The easiest way to do this is to choose your developer before you land your next project and get a copy of their contract so you can adjust your own, as needed.
2. Plan payments from your clients strategically
Just as important as protecting yourself when it comes to contracts is being strategic about how invoicing will work.
The normal invoice set up is:
- You send all invoices to the client
- Your developer sends invoices to you
Why your developer shouldn’t invoice clients directly
Occasionally questions come up around why the developer can’t send invoices to the client themselves.
The reason for this goes back to what we talked about in the first section of this post. It’s a much better experience for your clients if they don’t have to worry about invoices flying in from all directions.
On top of that, if your developer doesn’t have a contract directly with your client, they shouldn’t send them invoices.
With that being said, it’s important that you’re strategic in the way you set up payments. Luckily it’s nice and simple.
How to plan payments
All you need to do is make sure that you’ll have the appropriate payment from your client before the next invoice is due from your developer. That way, you won’t find yourself in the situation where you’ve already paid your developer for the next steps and then your client goes completely MIA, leaving you out hundreds or thousands of dollars.
So if your developer requires 3 equal payments throughout different stages of the project, set yourself up to do something similar, with client payments being due a week or two before your payments are due to your developer.
3. Take control of client communication
The last big thing you’ll have to worry about when it comes to managing a project with a developer is communication throughout the project. The basics are:
- You communicate with the client
- You communicate directly with your developer
- Your client and developer have no communication (at least until the project is completely over)
Why your client and developer shouldn’t communicate directly
Now, it might sound a whole lot easier to you to do things a little differently and just let everyone talk to everyone. But there are a few problems with doing it this way:
- Loss of information: When there’s not one single person controlling communication, information gets lost easily. In one project I was a part of where the designer didn’t want to manage communication we had a situation come up where the client had told the designer something, but not me. Then, both the designer and client assumed the other person told me, but neither did. This led to the client being upset that something was missing at the end of the project and extra fees for work that I hadn’t agreed to do in the original project quote.
- You lose control: Earlier we talked about how important it is that you have control over the final outcome of the project. When your developer and client are communicating without you, it’s easy for them to come to decisions that you wouldn’t recommend without your input.
- They don’t have a contract together: And last, if your client and developer don’t have a contract together, they simply shouldn’t be the ones communicating about the project.
How to handle communication
Managing communication with both parties doesn’t have to be difficult. In fact, it usually comes pretty naturally. Since the project can be thought of in two stages, design and development, it’s natural for you to be communicating with your client more heavily in the beginning and your developer more heavily near the end.
To make things even easier, since you are technically your developer’s client, they may take responsibility for setting up where and how the two of you communicate if you don’t have strong preferences for a specific system you use.
For example, I have my own development process outlined in an Asana project, which I add the designer I’m working with to. This almost always becomes our primary place for communication and the designer doesn’t have to worry about managing or setting up anything extra.
Rethink your project management process
If you’ve been doing things differently up to this point, it may be time to rethink your process. For the most part, it will only take a couple simple tweaks that will make your projects easier moving forward.
If you’re still working towards your first collaboration with a developer, keep these things in mind as you go into the planning process.
To learn more about working with a developer, unlock the ultimate checklist to go from hours of code to development-free design projects. Click the button below to get started!
