tags:

views:

580

answers:

5

We just finished a small project for a client (~35k), and the client would like to open a service contract with us to respond to any issues within 4 hours. The client would pay a monthly fee regardless of if there are any issues or not. Since this is a new product, it is likely that there will be issues, but we think that they would be small.

We're in Salt Lake City, and the client is as well. We're using a c# front end and mysql backend.

I've read that some people charge by the hour after fixing bugs for free the first 3 months.

Should we go with a service contract and how much should we charge per month so that we don't shaft ourselves? Or should we go with an hourly rate to fix issues as they come up?

+1  A: 

Hourly is the safest bet, especially if your company doesn't yet have a comfort level with predicting errors.

Nevertheless, service contracts are almost alway better for the developer for two reasons.

  1. You should have an information advantage for predicting the number of bugs based on previous software you've developed and bugs found so far.
  2. It is expected that you'll pad the fee for safety's sake and company's are often happy with this arrangement, because many businesses prise predictable expenses over getting the best deal.

Seeing as they are offering a service contract, I'd lean strongly in that directly and would only choose hourly if I was very worried that I couldn't predict the number of tickets.

If you go this route, look into competitive or somewhat similar services that other companies offer and look at their pricing scheme. This is the probably the best data you'll have on reasonable prices.

Best of luck!

Michael La Voie
+6  A: 

In today's economy, take the service contract with some protection for yourself.

  1. A contract should provide stable cash flow. For example, a 24 month contract with a $500 to $1000 retainer is a guaranteed $500 to $1000 each month for 24 months. If you are just hourly, you may never get any of that. You should also guarantee the contract for the full length and if they cancel, require a payout of 4 months.

  2. It should create an opportunity to be placed on a retainer as well as set some kind of hourly rate up. Maybe its 10 hours per month of support and $150 per hour for each additional hour after 10?

I just threw the $ values out there. Does this company seem like they want to spend a good amount of money for good support, or are they looking to save some pennies here and there cutting quality?

RSolberg
Mainly the latter - they are looking to save some money.
Justin
@Justin - you will be leaving money on the table if you don't take the contract.
RSolberg
+5  A: 

I always reccomend the service contract. I've been doing that for 8 years and it is a win/win. Here is a few of the many reasons why I feel it is better.

  1. Clients prefer this arrangement b/c it's is a predictable, budgetable cost.
  2. Allows client/developer freedom to continue to improve the product. Having to generate estimates/approvals for each small change and bug fixes can be prohibitive
  3. The developer can become more part of the long term business strategy for the organization.
  4. Developer can better allocate time and resources, especially if they need extra help.
  5. Reduces conflicts on "what is a bug" vs "what was left out of scope". Attention is strictly focused on creating a better product
Cody C
I agree that having an arrangement is a good thing, but I disagree with your 5th point if we're talking about a fixed monthly price for "as much work as is needed". Having the requester not have any hourly fee for work is *begging* for fights about "bug" vs. "out of scope".
Jonathan
+8  A: 

Advice: Start with hourly fixes. Unless you are dead confident in your code and the airtightness of everything you put in a spec and put blueprints on, go hourly.

Why?

Every time I have launched a new project I try to leave it hourly to build a history of cases that need to be resolved. Once I have some data (average amount of time to fix, type of bug, etc) to back it up, I see if I can average out a price for the year. So If I figure I use 100 hours a year of "support", I can then come up with a yearly cost, pad it due to the programmers genetic make up of underestimating and then present it.

Critical considerations for service contracts:

First, it has to be good for you and them. It has to stay good for you and them. There can't be more bad months than good for either of you. Regardless of what you are paid you will have to present value or lose the support agreement at renewal.

  • What does it cover? You must be careful when it comes to Fixing "anything". Becoming the catch-all to support the entire application even if it's not your problem (hardware, or network issues, etc) is very costly, first to your time, and second potentially to your image, if you are being called for a central support resource for the entire application.

  • 4 Hour what? 4 hour response is much different from 4 hour resolution. The only thing you can offer is the first, the second is a bonus for 60-80% of cases. If they want the latter, add a zero to everything. You may need to staff an extra person. You will also have to track your own performance (response time, etc.)

  • Define Support. Training? Meetings? Answering Questions? Bugs only? Don't become a free department that needs to be on call 24/7.

  • Priority. - I set all my cases with priority. Only Priority 1 or 2 cases (out of 7) should be 4 hour response time. That way any fires get attention appropriately and the smaller bugs keep getting fixed.

  • Cap the hours/bugs monthly. - Cap the number of requests, or fixes per month if you insist on going on a support contract. So, up to 50 hours a month, or up to 10 priority 1, and 10 priority 2 cases, etc. Anything beyond 15 blazing infernos a month and its x per incident, where each incident is so many hours. It entirely depends on your customer and their habits. The ones who break stuff a lot and need more of your time and attention personally will need more checks and balances for both sides to be happy.

  • Be optomistic, but be realistic. With a new project neither of you know what may come. So for you to cover your unknown, what could be the absolute worst amount of time that could be spent? It's often best to work from worst case estimates instead of best case. What you're selling is essentially an insurance policy. The more unknowns and lack of data history there is, the higher your insurance policy would be, right?

  • Have an air tight process. - Have a mutually agreed upon way of defining what is support and what is a "change request" for new or modified functionality. Be sure you have the appropriate signoffs for analysis (mutual interpretation), design (how you're going to build it), and signoffs for launching so there can't be any pointing back to mis-interpretations or mis-understandings.

  • Subtle abuse - Clients, often, will make you do the leg work after a contract is up. Something looks wrong... but isn't? Send it to you to figure it out. Over time you can spend so much time supporting inquiries of where "it isn't working" when, in fact, someone is simply using you as the path of least resistance to answer their question, or what they are assuming about how it works since they have forgotten. So, to clear your name you have to show that it was how the system was used.. and not something that happened spontaneously like a bug.

So, after all that.. how to bill?

  • Sliding scales for billing? Set your rate at $125 hr for priority 3 and 4 fixes, and $150/hr for Priority 2 and Priority 1 fixes. This will also encourage them to truly prioritize with their wallets and give you some breathing room to fix stuff before it becomes a raging fire. I always present it like, don't fix things that don't add value to the bottom line. Priority 1 cases are minimum 1 hour. You could be booked on other work and have to be interrupted to do it, because like everyone, you have your development time scheduled.

  • Billing hourly and working up to a contract may build trust. Building this relationship further that you're always going to act in their best interest and spend their money at least as good as your own, if not better is a great way to win more business. If they want a support contract and you say "lets just see first how much it needs to be instead of picking a high number and it not being good for you", they will respect you that much more because you are not gouging them. This, again, is best with clients that you have a good relationship with, who will likely refer you other work. If on the other hand there is a lot of devils in the details, it may be best to stick to hourly, period so they can control their decisions on what they want to address, or not.

Wild Guess:

Chances are if your client wants a support contract (maybe even approached you), they are likely very happy with you, your process, the quality of your product, and the value you have generated for their business with their $35k investment in you. They want to make sure your attention is kept for them because it is of value to them.

Jas Panesar
very useful! thanks!
Maximiliano Guzman
Thanks for the well thought out answer - we'll definately set up a bug priority system, and probably go hourly for a month or two to get a feel for how they use (and abuse) the product. After that, we'll look at it again and renogotiate the contract.
Justin
@Maximiliano; thanks!@Justin; Glad it was of use. Be mindful of the customer wanting to cap their costs. A service contract is not low-end insurance, but rather mid to high end insurance on the premium scale... do post an update on how it goes!
Jas Panesar
A: 

I think you're certainly better with service contract, since it serves as a warranty on your software and if you're trying to build a reputation it's in your interest to have a bug-free installation too.

How to estimate? I would assign it to one person, one of the lead developers of that particular project. Let him estimate the error rate, and see if it's likely to be, for example, 1/3 of full-time. He might need to spend some time refreshing memory, and for that reason it better be one person.

So, for example, you bill them 1/3 of fulltime position, but I think your programmer still should get paid for the work done (and in the worst case you'll have to allocate more people). So your company as a whole either eats losses or gains a fee.

ilya n.