You’re ready to build a new web application (or refactor an existing web application). After reaching out to a few firms, you receive proposals ranging from $5,000 to $500,000 for the exact same project. You’re confused about the wide range in estimates and you probably don’t know where to start.
How do you know what firm to hire? What’s the difference between them? How much should you pay?
Let’s take a look at some of the five most common mistakes made when hiring a web development firm, as well as how you can avoid these mistakes and make the right choice.
#1: Lack of clear requirements
Many businesses don’t have a clear idea of their web application’s requirements. While you don’t need to decide on every technical detail upfront, it’s important to provide developers with unambiguous business requirements to ensure that you’re on the same page before writing any code.
For example, suppose that you want users to be able to sign in to your application. User authentication may sound like a straightforward request, but it’s not clear how they should authenticate (e.g. email address or username) and if there should be any validations in place (e.g. password length).
The lack of clear requirements is also why quotes vary widely between web development firms. Low-cost firms may assume the bare minimum requirements, while higher-cost firms may assume more extensive requirements. Clear requirements can help reduce this ambiguity and enable accurate estimation.
How to write clear requirements
High-quality web development firms use many different tools to ensure that everyone’s on the same page before writing a single line of code. With clear criteria in mind, efficient development teams will write tests based on the requirements and then write the code to make those tests pass.
Some of the most popular tools include:
- User Stories: User stories express application requirements in the form of a simple story from a user standpoint. For example, a user story for authentication might read: “As a User, I want to sign up with my email address and password so that I can access my account.”
- Wireframes: Wireframes are sketches of a web application’s interface. Rather than spending time on a high-fidelity mockup, wireframes are designed to serve as a starting point that’s easy to adapt and change as the application evolves over time.
- Critical Paths: Critical paths are high level sketches of how a user moves throughout the application. For example, a customer ordering a product from an e-commerce application might visit the homepage, search results page, product page, shopping cart, payment page, and confirmation page.
You may want to run through these exercises on your own before reaching out to a web development firm. For example, you can sketch out the critical paths and come up with some basic wireframes to provide developers. These materials could help generate more accurate quotes to help with budgeting.
When interviewing prospective web development firms, you should ask what their processes are for understanding requirements and communicating over time. The best firms take the time to understand requirements before writing code in order to deliver what you want on time and on budget.
#2: Not making enough time
Many businesses outsource a software project to free up internal resources to focus on other areas, but that doesn’t mean the process should be entirely hands-off. In fact, a lack of communication is frequently cited as a leading cause of failure for software projects.
For example, suppose that a developer doesn’t understand a requirement. They would ideally reach out to you for a quick answer and move on with the project.
If you’re unavailable, they may be forced to choose between two bad options:
- Make an Assumption: They could make an assumption about the requirement. If the assumption is wrong, they will have spent billable hours writing code that needs to be rewritten.
- Wait for a Response: They could wait for a response from you about the requirement. If you take a long time, it could delay the current sprint and extend the project timeline.
These are avoidable problems that can dramatically improve a software project’s odds of being delivered on time and on budget.
How to improve communication
High-quality web development firms prioritise communication. If you can’t meet in their offices on a regular basis, they should provide access to tools like Slack, GitHub and Trello, enabling you to provide rapid feedback. Never put them in a situation where they don’t receive rapid feedback.
Some popular communication tools include:
- Weekly Meetings: Weekly meetings with the web development firm provide an opportunity to answer any questions and review exiting progress. By catching any problems early, you can avoid wasting time and money.
- Remote Tools: Team chat applications, such as Slack, make it easy to quickly communicate remotely. If a question arises, you can quickly respond and avoid interrupting the development workflow. Trello is also helpful for seeing where a project’s tasks stand at a glance.
You should appoint a point person to be responsible for handling communication with the development team, as well as setup communication tools in advance. That way, there’s never any ambiguity about who to contact with any issues that arise and responses will be prompt enough to avoid delays.
When interviewing prospective web development firms, you should ask about their communication processes. What tools do they use to include you in the process? How often are meetings to assess progress and answer questions?
#3: Hiring based on price
Software quality is easy to ignore since you often can’t tell the difference—at least early on. It’s a lot like purchasing a used car: It looks very new and seems to work just fine until you start putting on some miles—it’s only then that the maintenance issues start to surface.
Poor software quality can lead to several issues:
- Errors: Many errors aren’t immediately obvious when testing the application in development, but they may come up frequently in production.
- Performance: Performance degradation isn’t obvious during testing, since there’s very little traffic, but it could become a big problem in production.
- Maintainability: Poorly written software is much more difficult to change and maintain over time, which means you may need to pay more down the road to update it.
Some of these problems arise from the lack of clear requirements or timely communication, as discussed earlier. Other problems arise when a project is behind schedule and developers take shortcuts. And still others occur when a development team doesn’t include knowledgeable senior developers.
How to balance price & value
Try to find web development firms that offer the best *value* by finding the balance between price and quality. While quality is a subjective measure, there are some important considerations that you can ask yourself when interviewing prospective web development firms.
Some important questions to ask include:
- Experience Level: How long has the company been around? How respected are the firm’s team members? Do they have a lot of testimonials and case studies? Are they proficient in the technology stack you’re using? Will your project have a combination of junior and senior developers?
- Project Management: How do they understand requirements? How do they set timelines? How do they communicate milestones? How will they reach you if there’s a question about implementation? What software development approach do they use (e.g. waterfall or Agile development)?
- Consistent & Responsive: Does the firm have consistent processes in place? Are they responsive to your emails and phone calls? Do they seem professional?
When interviewing prospective firms, you should also ask to see their past projects and talk to past customers. Ask past customers about their experience working with the firm and any challenges that arise. You can even look at any open source contributions that the firm has made to assess code quality.
#4: Rewriting the application
Suppose that you already have a legacy web application and you’re looking to eliminate errors, patch security vulnerabilities, improve performance, and make it more scalable. These are common requests with varying levels of difficulty depending on the existing application.
Many web development shops specialising in certain languages and frameworks may recommend that you rewrite the application in newer languages or frameworks. The problem is rewriting an application is almost always more costly than refactoring.
We have found that the vast majority of legacy software applications can be refactored to meet the desired goals at a fraction of the cost associated with a rewrite.
How to decide on a rewrite vs. refactor
High-quality web development firms should be open to both refactoring and rewriting based on your requirements. The best way to decide between a rewrite or a refactor is to understand the motivation for updating your web application.
Some of the most common motivations include:
- Architecture Issues: The code is unorganised and difficult to update. These problems are best solved by refactoring the code rather than rewriting it.
- Performance Issues: The code may have poorly written SQL queries that make it unresponsive or bugs that are causing intermittent problems in production. These are issues that can be quickly fixed with a refactor.
- Deprecated Frameworks: The framework that you’re using may no longer be actively supported. In this case, you may want to consider a rewrite to ensure security and maintainability over the long-term.
- Excessive Complexity: The code may be too complex and interconnected to refactor. A rewrite may be the best option to solve these issues, but some code can be reused.
You should carefully consider your motivations for updating a legacy web application before reaching out to a web development firm. Depending on those motivations, you should have a rough idea of whether you want to pursue a rewrite or a less expensive refactoring process.
When interviewing prospective web development firms, be sure to ask about their opinions on refactoring the application and be wary of those that aren’t willing to entertain the idea.
At Siftware, we specialise in updating and maintaining legacy PHP web applications. Our clients’ applications are usually mission-critical in their business, but may have been ignored for years and require significant updates. We can help bring them back to life without investing in a complete rewrite.
#5: Ignoring the infrastructure
Web development firms may lock you in to specific architecture or even control the architecture. If this is the case, you may not be able to easily switch web development firms or transition to an in-house team. You could also lose control over flexibility and cost structure.
For example, suppose you hire a web development firm to create a real-time inventory management application. Without your knowledge, they use a third-party service to handle the real-time communication elements. But shortly after the application is finished, the third-party service shuts down.
Or, suppose that the web development firm tightly couples the application to a server that they operate. New developers cannot easily install the application on their local environments and it’s nearly impossible for you to move the application over to a new server.
How to make infrastructure decisions
High-quality web development firms decouple the application from the infrastructure, so it can be easily moved across servers. In addition, they are upfront about any third-party dependencies and external services, explaining the benefits versus the costs of using them.
You should carefully consider assets, such as:
- Domain Names: These are the .com, .net or other top-level domains where the web application will be hosted. These domain names should be owned by your company and setup in accounts under your business’ name.
- Web Servers: These are the servers where the web application will be hosted. These servers should be setup under your business’ name and the development firm should provide you with the relevant credentials.
- External Services: There are many external services that web applications may utilize, such as Firebase for real-time communication. You should be aware of these services and the costs and contracts associated with them.
- Source Code: The source code should be hosted on source control and continuous integration servers that you own. That way, you can easily invite other collaborators and remove the web development firm from the project, if needed.
When interviewing prospective firms, ask them about the portability of the code they develop and any third-party dependencies or services.
At Siftware, we regularly help make legacy PHP applications more portable. We write scripts to automatically build new servers, including both production and test servers. You can easily move the application to any host and new developers can quickly make local copies of the application for development.
The bottom line
Software projects fail for many different reasons, but the good news is that most problems are preventable. By being aware of these five common mistakes and adhering to the best practices needed to avoid them, you can increase the odds of your project being delivered on time and on budget.
If you have a legacy PHP application that you’d like updated, contact us for a free consultation to learn how we can help you.