I work for a small, independent software development startup. We’ve been in business for nearly three years now and things are going pretty well. We’ve got a pretty steady stream of projects for an ever expanding client base, and as a result have carefully started hiring new staff and temporary help. We’re now at five permanent members of staff, of which two are full-time developers and one divides his time between development, design, and managing the business.
Because the workload has been getting higher, we’ve run into some problems: we’re making long hours, are missing deadlines, are unable to give accurate estimates regarding when a project will be completed, and the quality of our code is dropping. I’ve been asked to come up with a development process that better fits our company and projects.
We usually work on several projects at once – this is inevitable duet to the amount of projects we’ve taken on and the small number of developers we have. We currently more or less divide this up in two week intervals: work on project A for two weeks, work on project B for two weeks, and then inevitably some problem with project A or C will pop up and we’ll spend a day intended for project B on project A and C.
Our clients are from all over the country and from various backgrounds. Some are talkative, some are not. Some expect weekly updates, some have no problems with not hearing from us for two months. We prefer to work in small iterations: get a prototype out the door and into the client’s hands as fast as possible (usually about a month after development started) and then iterate on that every two to four weeks. We’ve found that this is essential for the kind of projects we do and the fact that our clients often have no real idea what they want until they’ve had something approaching what they want in their hands for a while.
Right now, our development process is pretty straight forward, but obviously lacking. Our designer comes up with an idea for an application and a rudimentary graphic design, and our developers (one, two, or all three) sort of divide the work on an ad hoc basis and start building. Every now and then, we check where we are, and adjust if necessary. There’s not much more to it than that.
I’ve been thinking of doing code reviews: every piece of code is checked at by at least one developer who didn’t write it. This seems like a good way to start improving the quality of our code, but it takes a lot of time that we just don’t have. The same goes for unit testing: we’ve spent weeks writing tests and often found ourselves constantly having to tweak the tests because we found out they weren’t testing the right things, or weren’t testing enough. That project took significantly longer than projects where we didn’t unit tests and just squashed bugs when we found them. Also we didn’t have anything to show the client for weeks. Possibly we were just doing it wrong, of course.
I’ve also been thinking of adding a dedicated tester to our team: someone who finds, categorizes and reports bugs to us, so the developers have to spend less time finding bugs and playing support for our clients, and have more time to spend on actually fixing bugs and developing the application. Obviously this is a significant investment for a small team like ours, but I have a suspicion that it’s a more effective way to spend money than just throwing more developers at a project.
As to providing better estimates, I have no real idea. We’ve dabbled in planning poker, but in my experience that amounted to little more than the wildly inaccurate guesswork we were already doing. Finally, I want to formalize the design process more, to a certain extent. Obviously due to the iterative development we can’t really set any design in stone, but it probably wouldn’t hurt if we spent some more time up front formalizing both the application architecture and the graphical design.
Basically, I have a reasonable idea of what we can improve and what we’re currently lacking, but I have no real concrete ideas about how we can achieve this goal. Hence, I turn to Stack Exchange. There are probably many of you in companies similar to ours who struggled with the same problems. How did you overcome them, or what traps did you fall into that you’d suggest we avoid?