Running a successful software project: the developer perspective

Running a software project can be tricky business. From working out what needs to be built, to squashing those pesky bugs, to managing ever-growing codebases – there’s always something that needs doing and loads of technical jargon to cut through.

To help, we’ve put together this guide with our insights about running a software project, from a developer’s perspective – to set you up for long term success.

Research the technology

Spend time researching which technologies to use before starting – this is known as your “technology stack”. This includes programming languages, databases, hosting, to name a few, and you should make conscious decisions considering the trade-offs of each tool, as this can have an impact on the project in the long-term.

Key factors to consider include talent availability, popularity, costs, and support. Choosing a popular, well maintained and supported technology helps in the long-term. Otherwise, it’ll be hard to find contractors to maintain and evolve the code, and the cost of improvements will increase.

Plan for the future

Ensure your software developers are aware of the purpose of the software, and what plans there are to evolve and extend it going forwards. You can’t expect a developer to put in place the infrastructure for code and future features, without knowing the destination.

However, focusing too much on long-term aims can mean valuable time is spent over-engineering the code in the short-term, when that time could be better spent getting something working and revisiting it later.

Pay attention to technical debt

There is a concept of “technical debt” in software – and this works very much like financial debt. If a new feature has been added in a hurry, this can often introduce key structural issues in the code that need to be resolved at some point. Continuing to add new features can compound the issue, causing future headaches. This leads to increased cost and effort required to improve quality over the long term.

So when a developer says that their code needs to be “refactored” – they mean that they need time to reorganise and restructure, to make the code easier to work with in the long term. This can be a time-consuming process and may affect currently working functionality without directly appearing to add value. However, the intention of this is to make the code easier to work with, improve the pace of adding new features, and increase reliability.

The downside of delaying this is that the debt builds up over time, and the more code that is added, the longer it takes to sort out. If this is never addressed (and this often happens when there are tight deadlines or tight budgets), the debt builds up and the code quality reduces. Eventually the conversation turns to scrapping it and starting again because it’s become unmaintainable and painful to work with. This leads to frustrated developers, frustrated managers, and frustrated timescales, with poor productivity and results overall.

Time should be scheduled in to pay down this technical debt, through activities like documentation, refactoring, and testing. This shouldn’t be overlooked, as sorting these issues can dramatically improve future productivity, reliability, and quality - reducing bugs and problems that cause headaches.

Keep on-top of software updates

Software projects are rarely finished. There’s always one more idea to add, one more bug to fix, or one more update needed to keep up with new devices and operating systems.

Planning for ongoing development and essential maintenance is essential to ensure the software continues to work headache-free in the long-term. Companies like Apple and Microsoft release new devices and software updates very frequently, and your software will need to keep up.

Developers also use libraries and dependencies in their code – these are third-party pieces of code that help solve technical challenges and increase the speed of development. These third-party libraries get updated frequently, and time should be scheduled to keep on-top of these before your software gets outdated and it becomes a much bigger job to sort out.

Conclusion

As you’ve seen, there are many factors to consider when planning technical aspects of software projects for the long term. Choosing your technologies wisely, accounting for essential maintenance activities such as refactoring, and keeping on-top of updates from the start will help ensure the project runs smoother, the code is higher quality, and you achieve your business goals - without the headaches.