Development processes for successful software
Successful software exists, and it isn't an accident. It usually happens because the development team thinks beyond writing code and considers everything else it takes to release software:
- Project management
- Release and configuration management
- Quality assurance
- Production release
- Production performance, maintenance and operations
- Customer support
- Continuous improvement
- Creative work environment
When a team takes these areas seriously as it designs, develops and releases a project, nobody's time is wasted, other groups come to appreciate the development team, and releases go much more smoothly. Much of what follows is common sense, yet time after time I see teams and individual developers neglect it. Other teams mean well but don't have the time. And groups outside development often don't see the benefit of these practices. I hope this article helps development teams, and the rest of the company, recognize that benefit.
Development process
Requirements review
The first step is to understand, as clearly as possible, what you need to build. How requirements are gathered and documented varies widely from company to company, but every process ends in some kind of communication to the development team about what's needed, and the team has to come away with a clear picture. Sometimes that picture takes several release iterations to sharpen. The point I want to stress is this: when something is uncertain, the developer needs to do the legwork to resolve it and keep a written record of the answer. Verbal resolution is usually not good enough. You want proof that this was the resolution as it could be forgotten. I've seen this happen hours before a production release.
Design review
Once the team has a fairly clear understanding of what's expected, design begins. Again, practice varies by company, from detailed design specifications to informally explaining the planned approach to a lead developer. Either way, the design review matters because it surfaces problems early, when they're cheapest to fix, and that saves critical time and money later. Don't waste other groups' time by releasing substandard code. Ideally, the people who review the design have system-wide knowledge and experience.
Code review
Once the design is agreed on, coding and unit testing begin. As the work nears completion, hold a code review. Catching issues before the release goes to QA saves time and money. Don't review only the code; look at it in its wider context. Cover these areas:
- Content of the changes (new features, bug fixes)
- The source code
- The testing
- Supporting documents, such as release notes and operational guides
I recommend a code review template to capture the action items from each of these areas. The template's review section should record every comment and suggestion from the participants, which is an important part of fostering an open, creative and innovative environment. Not every item needs to be addressed, but every item should be captured. The participants decide whether each item goes into this release or can be deferred.
Documented test plan
During design and coding, keep notes on how each feature should be tested. Turn those notes into a formal test plan and give it to QA no later than the first release to QA. The plan formalizes communication between development and QA, and production support teams often rely on it too. In some organizations QA writes the formal test plans. Even then, the development team should document its own testing.
Automated build process
Whatever build tool your team uses, the build scripts should be rock solid and easy to rerun. Externalize any configuration tied to a developer's workstation. Script both the build and the packaging of the release, and make the package match the production installation image as closely as possible. Once the scripts exist, keep looking for ways to improve them. You can often build tests into the build itself, which steadily raises the quality of the basic release artifacts.
When you're ready to release to QA, go through the process twice. First, make sure all the code for the release is checked into source control. The developer designated to cut the release checks out the code, builds and packages the release, and inspects the artifacts closely. If everything looks right, label the source, back up the project directories, and then delete them completely. Now go through the process a second time, checking out the source from the label you just created. This proves the release doesn't depend on anything that exists only on the developer's machine, and it guarantees the release can be recreated.
Source code management
Use source control to support new releases and to recreate existing ones. I use a branch-by-task strategy: every feature or task gets its own branch. At release time, the tasks chosen for the release are merged into an intermediate integration branch. If the integration branch passes development testing, it's merged back into the main code line and the release is cut.
Release management
When your build replicates the production installation image as closely as possible, the handoff to release and configuration management gets much easier. Thinking about the production image early lets you anticipate what a smooth, painless production installation will need. If questions come up, talk to the release management team. They'll appreciate being asked and will usually be glad to help work the issues out.
Quality assurance
Your development process should be solid enough to avoid unnecessary QA cycles. While a release is in QA, make yourself available to answer the QA staff's questions. That keeps questions from being logged as bugs, and it keeps each point of confusion in a conversation between two people. That's usually better than exposing the confusion to a wider group, where it can make the development team look as if it hasn't thought things through and erode other groups' confidence in it. Each question also shows you where to improve your process so the same confusion doesn't come up again.
Project management
This is where development teams often face their biggest challenge. I've seen teams present realistic estimates that were rejected on the spot, and then be forced to revise them to fit the project manager's timeline. I recall a manager presenting a development schedule estimated at eight weeks. The project manager's response was "no way," "for these requirements?" and "did you really read the requirements?" Eventually the development manager agreed to six weeks. The scope of the release didn't change. The six-week timeline was then communicated to a wider audience, including the end-user community. When the project took eight weeks, the project manager was genuinely confused about why it ran two weeks over and questioned the team's ability to estimate.
Estimation is critical to a software project's success. You must provide reasonable estimates and stick to them. Don't compromise unless you get something of equal value in return, such as a dropped feature or an added resource. Otherwise, make it clear that pulling in the schedule may compromise the quality of the release. My motto is "under-promise and over-deliver." Your team will look much better one week early than two weeks late. In the end, most companies come to see the benefit, to internal teams and external customers alike, of delivering on time, and managing expectations and estimates well is a big part of that.
Customer support
Customer support is critical. Poor support leaves the impression of poor software. Excellent support gives customers confidence and leaves the impression of quality software, or at least of a culture of customer-focused continuous improvement. The development team can help build a first-class support group by paying careful attention to everything in this article. Good documentation, and a prompt response when support needs expert help, also make a huge difference, so don't neglect this part of the process.
Managing the knowledge all these processes create is an ongoing and critical job. Developers need to be knowledge management experts. Wikis are ideal for this. Whatever knowledge repository you use, keep it current. Don't let the information go stale.
Continuous improvement
Development teams need to measure the results of their processes and improve wherever they can. The processes in this article aren't static. They need to be adjusted for your organization, measured and improved upon. Continually. That takes a real commitment to a holistic discipline of software design and development.
Creative work environment
Foster a creative, innovative environment. The team should always be open to ideas and suggestions that improve processes, policies and software, and should encourage them. Periodic idea storm sessions, where everyone is comfortable making suggestions, help. Capture every suggestion and don't debate the merits during the session, so people can speak up without fear of having to defend their ideas. It's a fine line. Discussing an idea is valuable, because others often join in and refine it into something better, but no one should judge an idea during the session.
Conclusion
Every part of the development process described here takes the other groups in the company into account. That's what leads to quick iterations and earns those groups' confidence, and in the end it's critical to the success of the software. Quality assurance, release management, project management, operations, executive management and, ultimately, the customer all benefit from a solid development process. They'll appreciate the attention your team paid to quality, performance, release and operational issues. They're as busy as you are, so don't waste their time.
Dedication
Dedicated to my dear friend and colleague Alan Beale, who passed away in 2018. Alan encouraged me to write this article when we worked together at NYSE. I worked with him at Season Tickets, NYSE and Chicago Trading Company. He was a great mentor and was instrumental in my career, including recruiting me to NYSE and to Chicago Trading Company. I'm forever grateful for the time I shared with him in this life.
First published July 27, 2012. Revised October 2026.