We follow a carefully executed project management process for all of our software projects. You can read more about the nitty-gritty of the process we use at the Web site of the Project Management Institute. In a nutshell, though, all of our projects go through these project management phases:

(By the way, we realize the following is a bit text-heavy but we feel that it is worth a read to understand how, exactly, we tackle projects):

Project Management Phases

• Initiating—This is where a project comes into existence, the stakeholders are identified, a contract is signed, and so on.
• Planning—First we decide who is going to do what. Then we start gathering user requirements, creating design specifications and develop the schedule.
• Executing—This is where all the work gets done...the project manager steers the ship, the analysts do the rowing.
• Controlling—This is an ongoing, iterative process whereby the project manager and everyone else involved with the project is constantly on the lookout for oversights, possible SNAFUs, conflicts of interest, unforeseen risks, and the like. Also, this is when our analysts have their code reviewed by a second analyst for efficiency, errors and adherence to customer specifications.
• Closing—This is where the project is wrapped up, documentation is filed, and a "Lessons Learned" document ("What did we do right/wrong?") is created and distributed to stakeholders.

In addition, every software project itself goes through these software-specific phases:

Software Project Life-Cycle Phases

• Requirements Gathering—This is where our analyst(s) visits all parties involved in the software project, interviews them and ultimately puts together a document containing a narrative description of everything the new software should do.
• Design Writing—This is where our technical experts turn the customer's requirements into a "geek speak" technical design specification detailing everything the software will do in the chosen programming language(s).
• Coding—Using the design document as a guide, the analysts build the initial version of the software application.
• Testing—A complete test plan and script(s) are drawn up and our analysts run through the software trying to break it and making sure it works as it was designed to work. The client also tests the software, too, and ultimately signs of on its successful completion.
• Recoding—Inevitably, after the testing phase, bugs and new feature requests are uncovered. After changes are made to the budget and schedule (as appropriate), the analysts redevelop the software application. Retesting is usually also required.
• Implementing—When the software has been fully tested and debugged (and the client is smiling from ear to ear), the software is installed and users begin using it. After that, the users are usually smiling ear to ear as well.

All along the way, the project manager is also managing integration (when things get done), scope (what there is yet to do), time, cost, quality, human resources, communications, risks and procurement.

Why So Much Structure?

This may seem like a lot of stuff, but we've been doing this for a long time, so we know what to do and in what order. Also, the sad truth is that without structure, many projects fail.

Of course, we will thoroughly discuss the project management process and software development life cycle we use as it relates to your project from the get-go.