Jan 30, 2017 - John Entwistle

Five tips for efficient and effective agile development teams


We’ve all heard the saying that you can have low cost, fast turnaround, and high quality, but not all three at once. In today’s world of fast-paced agile development there sometimes seem to be sacrifices made to account for budgets and deadlines, but seasoned developers know that shortcuts can come back to haunt you later in a project. The following five tips can help any team produce high quality code without sacrificing time or money to do so.

1. Accurate requirements

First and foremost, having accurate and understandable requirements is a must. The less time that your team has to spend figuring out the details, the more time they can spend producing. And by limiting uncertainties, you can reduce the amount of work that needs to be revised and revisited. Ideally, requirements will be written by project stakeholders with their end users and goals in mind, and reviewed by a project manager or technical lead before being assigned for development.

2. Flexible code

Next, it’s essential to maintain an attitude towards writing robust, flexible code. When using your application users may - whether intentionally or not - interact with it in ways which weren’t originally foreseen. This is OK, and can even help you to make decisions about which key features to add next. However, in order to limit the time spent iterating over edge-cases and bugs as they are discovered by users, focus should be given to writing code that can respond to and gracefully handle unanticipated user interaction without negatively impacting the experience.

3. Peer code review

By having a well-defined peer review process for all code changes it is possible to not only help developers write hardened code, but also prevent a multitude of other common issues before they reach your testers or worse, end users. All code submissions, whether large or small, should be reviewed by a developer with some familiarity with the codebase with an eye for obvious errors in logic or syntax, code style and cleanliness, good use of design patterns, and even general functionality if possible. While enforcing a uniform code style and level of cleanliness may not always help to reduce the rate of bugs in software, it will help to reduce the time needed to make modifications later on, so adding that new feature won’t be so painful.

4. Test, test, test

Test, test, test! It’s imperative to have well-defined acceptance criteria and test cases, and a methodical approach to regression testing when new features or improvements are added. Automate as much of this process as possible, and when it’s not possible to automate ensure that your team has a comprehensive test plan. This starts from the bottom up - the same way that the overhead associated with HTTP requests can slow your application, the farther code travels from a developer before an error or mistake is uncovered, the more time is lost in communicating the findings back down the chain.

5. Incremental refactoring

Finally, don’t shy away from incremental refactoring. Oftentimes bad code is allowed to persist in an application because of a mentality of “If it ain’t broke, don’t fix it.” It can sometimes be hard to justify taking the initiative to improve code that appears to be working at the time, but doing so can have long-lasting positive impacts on the project. First, by improving code there is less likelihood that other changes down the line will have negative interactions with or unwanted side effects caused by the poorly written code. Additionally, by making the effort to refactor your team gains knowledge about the application, so when it’s time to add on or make changes they will be more prepared to hit the ground running on new challenges instead of having to take time to get up-to-speed.

By applying these methods to your development process it’s possible to produce amazing applications that both your team and stakeholders are proud of, without the feeling that any group’s needs were sacrificed to reach the end goal. Working together effectively and thoughtfully, it’s possible for an efficient team to produce higher quality code with less time overhead than other groups who don’t maintain this outlook.