Home › Company › Seven Deadly Sins

 

Get Started Now

  • Sign an NDA
  • Tell Rob about your project
  • Get a FREE estimate 
     

Get Started Now

 

 

"I have been very pleased with the exceptional level of communication, excellent service and end product. Thank you "MyProgrammer" for putting my idea into a well designed, carefully developed piece of software."

--- Saif A. Alzaabi , MD
(University of Alberta, Canada)

  

"I wanted to reiterate my happiness with how the project was run and completed. From setting up the project with Rob in the initial conversations to working closely with KJ to execute the plan, your service was first class, as was the final product."

--- Perry Lo
(Athletic Scholarships, California)

 

 

 

Bookmark and Share

 

 

Valid XHTML 1.0 Transitional

Seven Deadly Sins

I've been doing this custom software thing for a while, and I've seen or heard just about every mistake a client can make either before or after they've hired a software development company. My hope is that maybe you'll read this and not commit one of the Seven Deadly Sins.


Deadly Sin #1: Hiring Based on Price Alone

There's a reason this is the first deadly sin. It's committed more than all the other deadly sins combined. People have a tendency to think that all developers are the same, so cost should be the major determinant in who they hire. It's a big mistake, and unfortunately I've seen some people make this mistake repeatedly.  

In reality, hiring the wrong company start a viscious cycle. First, when you hire the wrong company you almost always commit one or more other deadly sins. For example, maybe you pay too much in advance. Or you don't set realistic milestones. And once you've paid out enough money, you sort of get stuck. It's almost like a bad marriage. Sure he cheats on you and beats you up, but where are you going to live if you leave him? And it is this sort of victim thinking that keeps you with a bad development company far longer than you should.

So how do you avoid this deadly sin? First, develop a checklist to rate the companies you are considering based on factors other than cost. Sure, you want to check references, review similar projects, etc. Those are obvious items. Here are some you may not have thought of:

  • Ask them how you are going to monitor the progress of the project.
  • Ask them if they use Subversion (or any other repository)? All reputable developers know what this is.
  • Ask them about Continuous Integration, and which tool they use to manage their builds. 
  • Verify the exact coding standards they use when documenting your code.

These are not iron clad questions, but I have interviewed many developers over the years and I am shcoked how many get all 4 of these wrong. 
 

Deadly Sin #2: Paying Too Much In Advance

If you committed sin #1, I can just about guantee you that you've committed this one too. Understand that I am not just talking about the initial retainer. You don't want to pay too much more than the work that has been done. If you do, the developer is stuck with a lot of work and no future revenue to offset this cost. But what about the money you already paid them? It's gone. It was used to finish another project before yours that also turned into a disaster. 

We structure our payment schedule around deliverables, or milestones. Basically we bill you for the next part of the project once we've completed the current part. We bill based on results. Keep in mind that it is critical that you understand how much of the project will be complete, and then make sure the payments you make roughly represent the percentage of the project complete to that point. 

 

Deadly Sin #3: Not Getting a Nondisclosure Agreement

If you have a real good idea, and your product becomes a huge success, the last thing you want to do is find yourself in a dispute with your programmer. It is critical that you have the company you hire sign a Nondisclosure Agreement which also assigns all rights to the software project to you. In fact, you should have this NDA in hand before you even start discussing your project with any company. Here's a sample of the one we give every prospective client. 

 

Deadly Sin #4: Not Owning the Source Code

You are hiring a company to write a lot of code. This code represents the product you are buying. You need to make sure that the agreement you sign grants you sole ownership of this code. Otherwise you've just paid your competitor to steal your idea. At MyProgrammer, you own the code. We have no rights to it, and we cannot claim royalties. You own it. Period. And yes, we put this in writing.

 

Deadly Sin #5: Undocumented Source Code

This has to be one of the most common of the deadly sins. Imagine this. You pay a company to write thousands of lines of code. When they are done the program works fine. You call the company back to get some changes done, only to find out the company no longer exists. Fortunately you recevied the source code from them previously, so you confidently search for someone else to continue development. And then you get the bad news. The source code has absolutely no comments or explanations describing why the code was written the way it was. This is a huge issue in our industry. In 9 out of 10 cases, the new developer is going to tell you it is easier to start over. And in many cases, that would probably be good advice.

We have a simple way to avoid this issue. We perform code reviews on a regular basis to verify that our coding standards (which include commenting source code) are being followed by all members of our team. Our internal audits are designed to make sure this exact situation does not happen.  

 

Deadly Sin #6: Not Asking for Documentation

You are paying good money for your software project. You owe it to yourself to get all the documentation the software company created during the life of your project. Why is this important? Imagine for a minute that the company you hired goes out of business a year or two down the road. What do you think the chances are of ever getting documentation? We provide our clients with functional specifications, business requirements, test cases, data dictionaries, and a host of other project artifacts. God forbid something happens to us. At least you have a good chance of finding another company to help you support and enhance your product. 

 

Deadly Sin #7: Not Doing External Audits

If you really want to cover yourself, you should hire another company to review the code your developer is building. This has several benefits. First, there's nothing like an external audit to make sure your programmers have double checked and fixed their sloppy code. The company you hire to do the audit also wants to give you value, so they are more than likely going to find some issues. This doesn't mean your programmers are bad. Everyone misses something every once in a while. But by letting the company you hire know from day one that an external audit will occur at some point, you are already putting everyone on notice. We've been on both ends of this, and the client always came out the winner for it.   

So there you have it. Seven deadly sins you should avoid if you want your software project to have a good chance of success. Good luck!