Software development is a complex endeavor; stack the odds in your favor by hiring the right people for the right jobs.
When you are ready to hire your first dev team, it’s relatively easy to just hire one developer and think that you are covered. The problem is that software is designed by teams, and each role within the team provides a specific value to a project.
There are a few of the critical roles on every software team:
- Designer
- Product Manager (Product Development Manager)
- Development Lead
- QA
It’s extremely challenging to find an individual who can work in all these roles and the best people are experts in their respective space. At Founders Workshop, we use a mix of talent and roles to help our clients achieve success in their software development project.
Crystal Taggart - VP of Development
Designer
A designer is an expert in the user experience (UX) aspects of the project. The software design they create captures 80% of the requirements of any system. A designer uses tools like Figma, Sketch, or others to create clickable mockups that help to define how the software should work, what data is captured, and the core look and feel of the software. The design they create is the foundation of the software documentation
A good designer is focused on the user experience and the brand experience.
- They create an experience.
- They create branding that evokes the feeling that the company wants the end user to experience – even down to fonts, icon choices and borders on tables, screens, images.
- They work to reduce the friction points for the end user.
- They ensure the software meets the requirements and goals.
- The work toward simplicity – is the software as simple as it can be?
Software design is a collaborative process and there’s many ways to solve the same problem. Often, the collaboration that occurs between the business, product manager, developer and design can help to create a better and more cohesive solution than one thought of by one member of the team.
Software is usually documented at a screen or process level so when reviewing stacks of documentation, you can often miss the big picture of the problem you are trying to solve and the experience from the user perspective. The prototype is the glue that ties all the pieces together because every member on the team can see the bigger picture while simultaneously focus on the detail.
Because people process information visually, it’s crucial to see a clickable prototype of the software prior to development starting. This helps to identify points in the process that are lacking and ensures a holistic experience from beginning-to-end.
By creating a fully thought-out design upfront, you can significantly reduce the amount of rework of the project, reduce scope changes, and ultimately, get the software you are envisioning.
Product Manager
The most crucial person on the team is the Product Manager. The Product Manager is the leader of the group. The Product Manager is the person who meets with the business to understand the requirements and rules, then translates that into stories for the development team to work on and leads the execution of the development.
With software development, the devil is in the detail.
A product manager helps to define the details upfront, reducing rework. It’s much easier to build a role-based system from the beginning, than to go back and analyze the code that’s been done and refactor the code to support role-based security.
With a constrained project team, the business has to prioritize what’s most important and the product manager can help guide them through the process of making decisions of where to invest now, and what capabilities should be deferred.
By thinking through the entire solution, a product manager can improve the quality of the project and ensure it’s done right, the first time.
Most developers are great at making assumptions to complete the work, then because they are paid hourly, it’s not a problem if they have to rework the code multiple times because they didn’t ask the right questions. Developers who work without a product manager guiding them typically run at about 30-50% efficiency rates.
A good product manager handles the details.
- They ensure the rules are well-defined from the beginning.
- They ask the right questions to think through exception scenarios and give you choices on how to solve a problem.
- They ensure the team is working on the highest priority items.
- They bundle together fixes so there are efficiencies in both the Development and QA cycle.
- Help to plan phases in projects, for example, some enhancements make sense to be done earlier, while other enhancements have a major system impact.
- They ensure the team members complete their own technical documentation on the project, making it easier to onboard others in the future.
- The last, and most important aspect, is that a good product manager makes sure everything is written down so the team can execute.
Many times hours of meetings occur discussing how to solve a particular problem. Often multiple solutions are proposed during the discussion. If it’s not written down, all the detail is lost. A vague requirement causes rework, lost time. If vague enough, a bad requirement can damage your software project.
The designer creates the vision, the product manager defines the detail so the team can execute smoothly.
Dev Lead
The dev lead is the leader of the software team. They define the technical architecture of the solution, the database design, the open source libraries used within the code, and often help to make decisions on integrated third-party solutions.
The dev lead’s time should be spent focusing on software design and overall code quality.
The dev lead is responsible for the design of the system to make sure it meets the needs of the business long-term and short-term. They build in logging so the system is easy to troubleshoot and maintain.
A good dev lead ensures the vision is delivered and the details aren’t missed.
- They ensure that the database design meets both the current needs of the system and the future requirements.
- They ensure that the software follows best practices for software programming languages, project setup, and documentation.
- Then ensure that configurable changes are stored in the database, instead of hard-coding everything. (Deployments = Downtime)
- They work with all the team members and assign them tasks where they can both be successful and grow their skills.
- They help to hire and onboard new members of the team, and sometimes offboard a team member when necessary.
- They lead the documentation efforts so new team members are productive sooner.
QA
Software is a human process and things get missed. It could be something as simple spelling errors or the software just doesn’t work the way it was defined. QA is the team that ensures that all the requirements are met and the software works the way that it should.
It takes a special kind of mindset to be successful as a QA Engineer. Most developers just test the happy path (the software works when someone uses it perfectly.) The QA engineer is the person who is actively trying to break the system, much like end users will do. They add special characters into a field to see if it crashes, they try to fit the contents of War and Peace into a description box to see what happens, they make sure that when you have a “charge this customer” form in your application, that you can’t enter a negative number, “accidentally” crediting the customer.
They look at the overall vision of how the software is supposed to work, they take the detailed requirements and create test cases ensuring that the software works as designed.
A good QA engineer ensures the software works the way it’s defined.
- They create detailed test cases not only covering the happy path, but also test the unhappy path and the errors that should be displayed when things don’t go as planned.
- They look at consistency across the application – are all the fonts the same, the styles the same, are there spelling errors or are there message boxes on one screen and popup boxes on another screen.
- They are the guardians of the quality of the project. They define the priority of the defect and when it should be addressed – is it a minor usability issue, or is it a showstopper that should delay a release date.
- They are instrumental in finding gaps in the design and requirements, prior to development even beginning.
If the product manager dots the I’s and crosses the T’s on the documentation, the QA engineer verifies that every I is dotted and every T is crossed.
The development team delivers the software product and the QA team makes sure that they methodically test every aspect of the product to ensure it works the way it needs to.
Summary
It’s very tempting for those doing their first software development project to hire a developer, and take on the roles of designer, QA, and PM themselves. After all. how hard can those toles be? The fact is, these crucial roles usually take 3-5 years to hone; an expert in designer, QA, and project management understand nuances that a rookie will most definitely miss and could mean the difference between success and failure.
It’s rare-to-impossible to find one person who can fill all of these roles.
By not hiring experts in these areas you can expect
- Increased software cost and timelines– the project that was supposed to take 2 months for $40k turns into 8 months at $160k because of poor planning and scope changes.
- Decreased stability of the software with unpredictable release dates and unpredictable quality.
- Decreased customer experience and increased churn (it takes people 5 minutes to decide if they like an app or not.)
- Burning through a dev team that over-promised and under-delivered on the project, then hiring a new developer who wants to write version 2 – then the cycle repeats and on to version 3, 4, and 5.
I cannot overemphasize the importance of hiring an expert in each of these fields to maximize your success in your software development project. Software development is a complex endeavor; stack the odds in your favor by hiring the right people for the right jobs.
TLDR
If you want a successful software project, hire experts to design the software, document everything, follow coding best practices, and test both the happy and unhappy paths.
If you want buggy software that partially works and exceeds the budget and timeline you planned and were promised – don’t.
