5 key steps to delivering a successful web app – Step 2


Building BlocksFollowing on from last month’s article on delivering a successful web app, this article deals with key step number two – constant open communication.

Here are the five key steps again that will get you closer to the successful delivery of your application:



  1. Planning and Documentation
  2. Constant open communication
  3. Flexibility
  4. A balanced team
  5. Testing and Launch

Step 2 – Constant open communication

We covered ‘Planning and Documentation’ in our previous article. The next important factor to consider when building web apps is people.

The ‘Planning and Documentation’ phase cements the essential foundation for the relationship between developer and client, and depending on the size and complexity of the project, could be a lengthy one.

As with any project, it is paramount that the lines of communication are kept open between the client and project team at all stages. This sounds elementary, but it cannot be stressed enough.

Unlike building a house where you can see when the foundations are poured and the walls built, software is much harder to gauge progress. It can appear to be taking shape one day and the next it can be completely broken, which can be frustrating. All the moving parts of software are interlocked. Developers often have to disassemble some elements to make them fit with new sections of code.

Project meetings can be buried in technical mumbo-jumbo with the many complex layers of software, so it’s essential that the project team strip away these layers and keep the client as informed as possible so they can make critical decisions about their software. This can be done remotely, but regular face-to-face meetings are far more effective when working through complex issues.

In our experience most developers hate meetings, but regular meetings and project review with both the client and developers in the one room create a united team approach – it removes the ‘us and them’ mentality.

5 Ways to Minimise Web Development Risk

1. Consult ALL parties

Access to the key players is vital at this stage. Although it’s important for all communication to be delivered via a single point of contact, both the client and development team must provide open and honest access to all relevant parties.

For example, if you are building an office management system or CRM, then the input of the people who use it daily (office manager, admin people, sales team) is critical. If the CEO’s mother is going to have the last say on the project, yet have no involvement in the construction, she needs to be at least interviewed early.

2. Scope and feature creep

Scope creep is the cancer of software development. It starts out small and barely noticeable – an idea, “wouldn’t it be cool if …” and before you know it your cool idea is costing a fortune in medical bills and threatening to kill the project.

It’s common, in fact expected that the scope will change as the project progresses, so it’s important to identify the costing of each idea early. The phrase, “wouldn’t it be cool if …” should be immediately followed by “what are the cost benefits?”


  • Keep notes and use a system to track requests
  • Issue a variation request and costing to the client to sign-off before proceeding with the new request
  • Clear documentation and sign-offs may seem like an inconvenience, but both parties will appreciate it in the end


  • Developing new business ideas can be exciting and you will be flooded with fantastic ideas as you live and breathe your new software development project. It doesn’t hurt to mention your ideas to your developer, but bear mind, some will be small and some will be big, but most will extend the scope, schedule and budget of your project
3. Slow or no progress

Slow or halted progress can be caused by a number of issues.

  • Miscommunication as to who was responsible for the next task (client or developer)
  • Either party may be under resourced with several projects on the go
  • The client is unresponsive to feedback requests and the developer moves on to other paying projects

The solution

  • Meet face-to-face and set weekly tasks with targets for both parties
  • If the developer is slipping behind, attach milestone payments to the project
  • If the client is not responding, the project manager needs to emphasise the impact the delays are having on the project and suggest they dedicate a staff member to the project
4. Bugs and Testing

The last 20% of a project places the highest amount of stress on both the project team and client. The client is usually desperate to get the project live and making money and the development team are in constant testing and review to iron out bugs. This can take longer than anticipated.

It is a common misconception that bugs are just the result of careless programming. No doubt, careless programming does cause bugs, but it’s not even a Top 10 culprit.

Remember, up until beta release only a small number of people have touched the project. It probably works well in a way that makes sense to them. However, as more people test the software, they use it in different ways and uncover errors, usability issues and an array of potentially complex issues. These must be worked through systematically. It will be tempting to redesign some things at this point. Don’t!

Launch the app as soon as you can and release updates often.

  • Client education is critical at this stage. All software will break in some way. Be ready for it and accept it is a part of the software development process
  • Weekly meetings and daily project team discussions
  • Track all bugs in a system that is open to both client and development team
  • The development team need to respond quickly to critical bugs to avoid client frustration
  • Note: Critical client bugs are not always critical developer bugs
5. My Developer has disappeared – Help!

Yes – this can and does happen, especially when using offshore developers. So, what can you do to minimise risk?

  • Again, engage in weekly review meetings either in person or via Skype (even if it’s just for 5 minutes)
  • Use version control software such as Github to ensure that you have access to the latest codebase – and– check that the developer is checking in the code daily
  • Have contracts in place to ensure the relationship is formalised
  • Check references of the developers to see a solid work history (as you would with any employee)

Keeping Web Projects on Track

As you can see, it’s all about engaging people regularly and openly. Communication throughout the software development cycle is often just about getting everyone singing from the same song sheet.

Weekly or fortnightly milestones are the most effective way we’ve found.

  • Discuss schedule, wins and losses, potential issues and possible variations that may affect budget and timelines as soon as they arise
  • Use the Specification Document as the ‘project bible’
  • Document variations in a formal manner
  • Set short-term deadlines that are achievable by the development team and/or the client
  • Expose the development process as warts-and-all. The client should see the bugs and broken pages at all stages of the build process. If you give them smoke and mirrors they will have a false idea of the progress
  • Use version control or code repository software like Github
  • Release early and often

About the author

Jason Hawkins is a senior application strategist, information architect and director at KND. His knowledge is based on years of industry experience in taking online application ideas to reality across a broad range of industries.

KND are web and digital professionals with over 10 years in the business. We specialise in web, cloud and mobile apps, eMarketing and SEO strategy, servers, hosting and design. We work closely with our clients to achieve successful outcomes. Call us today (+61 7 3832 4077) or email (enquiries@knd.com.au) to discuss your next project.


Related Articles