This article is for: Technical or non-technical software startup founders and development teams who want to make best use of agile software development methodologies to keep their development project on track.
Written by: Alex Senson, Ashley Burton, Tyler Boulanger
<– Back to: “How to Create Software: Development Techniques to Learn”
There is more than one way to build a great software product. When you are launching your new software startup, you should first consider which development methodology you will use during the development process. In this article, we will outline a comparison of the software development methodologies available, and how to select the correct one for your project.
This article is for startup founders who plan on developing a software product. Your company may have a development team and need to plan the development process. Alternatively, you may outsource to a development company or hire a freelancer to do the work. You will need to manage the process better and avoid pitfalls.
If you are hiring or contracting a development team, make sure you ask and understand what development methodology they will be using. It may be a red flag if they do not use a methodology, although some very small operations may not.
There are many methods you can use to build a great software product. The methodology you choose will impact who you will hire, how quickly they will develop new features, and how quickly you will receive and react to customer feedback.
Generally, the two main categories of development processes are traditional, and agile software development methodologies.
We will outline the advantages and disadvantages of some common methodologies and show how each could be the right choice in a specific situation. Use this resource to learn more about both traditional and agile software development methodologies and how to make an informed decision when building your new software product.
Main topics to be covered:
- Traditional vs. Agile Development Methodologies
- Evaluate quickly if the traditional or agile route is the way to go.
- Traditional Development Methodologies
- Learn about methodologies that focus on following a set development plan.
- Waterfall model
- Prototyping model
- V-model
- RAD model
- Spiral model
- Agile Development Methodologies
- How to Select Your Software Development Methodology
- Key things to evaluate when selecting a methodology and the Altitude Accelerator’s own development methodology decision tree.
We will illustrate these ideas through case studies of companies and founders who work with Altitude Accelerator
Software development – introduction
Software development is a set of activities that lead to the creation of a software product. The development process is applied to new software or modifying an existing program. It generally consists of the following activities (Figure 1):
- Software specification and requirements engineering,
- Software design and implementation,
- Verification and validation, and
- Software evolution and maintenance
Content development
Additionally, content development (for example, support material, marketing material, etc.) is also a part of the software development process. All of these activities working together allow startups to develop a usable product.
The order and flow of these key activities depend upon the software development methodology (SDM) chosen at the project’s start. There are many different SDMs used within the industry, each representing a content development process from a different perspective (for example, plan-focused or feature-focused).
Importance of software development methodologies
As a non-technical founder of a startup, you need to be aware of the different SDMs that could be used during your development project. At its core, the SDM selected describes how your development team will be reacting throughout the project.
For example, will they spend a chunk of time at the start developing a plan that cannot be deviated from (plan-focused). Or will the development team focus more on the development of features, and adapt to roadblocks flexibly (feature-focused). By determining the style of the development process at the beginning, the project begins with clear expectations, allowing your startup to track the progress of the project.
The selection of a SDM is a vital step of the development process. This is because the selection of an unsuitable methodology is the most critical risk of software development failure. Selecting an inappropriate methodology can potentially lead to the project running over budget, timeline delays, and a lack of requirement verification, all of which are considered project failures.
Traditional vs Agile Software Development Methodologies
Key Takeaway: Your startup can either use traditional or agile methods during development. Traditional requires significant upfront planning. Agile, however, allows you to react to issues as they occur.
One of the first decisions you make when starting development is deciding which approach your startup will use during development. Will the startup use a traditional (predictive) approach or an agile (adaptive) one? Most successful starts opt for an agile approach, and it is usually recommended by industry experts.
A traditional approach takes heavy front-end planning. Before any development begins, the team does a thorough requirement analysis and plans the project out from beginning to end. In a predictable environment, that can work really well. In a startup, it can backfire catastrophically.
An agile approach, however, consists of no detailed planning and only clear future tasks are identified. This methodology is applicable to startups most of the time because agile software development methodologies allow for:
- Dynamic changes in the software product’s requirements,
- Persistent testing, and
- Frequent interactions with the user
There are many different methods within these broad categories of traditional and agile approaches. Let us now delve a little bit further into each of the different methods available to your startup.
Altitude Accelerator Case Study: Expancio
Expancio is a startup that provides a tool to help businesses design, build and run their web application. With their product businesses do not need to create a web application from scratch. They instead can use Expancio’s platform saving significant development costs.
When Expancio began to receive requests for service from businesses and started to sign contracts the team knew they had to have a plan in place. This plan needed to cover how the team would complete each project successfully and efficiently.
According to Expancio’s Vice-President of Engineering, James Lee, an agile software development methodology was the only fit for them. “Expancio consists of a small team…and we want projects to be completed quickly, with a fast turnaround,” says Lee.
This decision was built upon his past experiences working with financial institutions to create web applications. Companies within the financial industry commonly use the Waterfall Methodology, where the entire development project needed to be planned out in detail before any work could be conducted. Banks then would follow a strict concrete timeline during development which could not adapt to any changes within the industry or market easily.
The main challenge experienced by Lee while working within the financial industry was that the creation of a set of detailed concrete plans increased the complexity of the project. This complexity was a result of trying to accurately plan out an entire development project, and cover all potential stages of development, at the start before any work has been completed. As the project’s complexity increased, the amount of resources and time required to complete the project increased as well.
Alternatively, the banking institutions could have used agile software development methodologies throughout their development processes. These agile methods would have allowed Lee to develop the required software product in small increments with in-development testing built right into the project plan. By utilizing these agile methods, Lee and the rest of the development team could have created the required product using a method that did not rely on upfront planning, but rather the results of in-development product testing leading the remaining development stages.
Based on all his learnings from past experiences, Lee recommended the use of agile development methodologies when the topic of what method Expancio should use during product development. As a startup, Expancio needs to be able to adapt quickly to changes within the industry to ensure that their product, and company, are not being left behind.
The use of agile development methodologies also allows Expancio to continue to validate their early commercial product. This continuous validation is made possible by agile methodologies, which allows the company to quickly change their platform based on user feedback. Any observations made by the users regarding challenges in task completion and design flaws, as well as bugs identified within the product, can be addressed during a new stage of iteration. By constantly iterating their early stage commercial product during the validation, Expancio is able to create a product that their users really need. This is instead of saving all opportunity for user feedback till the very end of development when a massive overhaul of the product maybe required.
Overall, the use of agile development methodologies allows Expancio to continue to grow and improve their platform. This ensures that their product does not become stagnant, and can easy be improved upon based on user feedback and any changes within the industry.
Traditional software development methodologies
Key Takeaway: Traditional development methodologies are highly structured and allow for limited flexibility during development. The most popular traditional methodology with startups is the Waterfall Method.
Traditional development methodologies result in highly structured projects. They are based on a series of back-to-back plan-driven steps.
During the definition stage, before development begins, the team plans out the entire process. This is done to guide members during the work phase of the project.
Startups often do not have clearly validated product requirements before development begins. This can present a challenge. As a result, resources may be wasted on development that needs to be changed later as the requirements evolve.
Software developers commonly use traditionally methodologies on projects that are:
- Large budgets (usually over $1 million) that allow for work to be redone
- Used by multiple medium-sized teams that are working on a single project
- Conducted by large companies
Although agile software development methodologies have become increasingly popular, traditional methods are still the most frequently used development style.
Advantages:
- Plan-driven process that is easy to understand
- Strict development roles for all team members
- Compatible with large teams and projects
Disadvantages:
- High cost to restart the development process
- Requires startups to know the software’s requirements at the start of the project
- Fixed development process with limited, to no, flexibility allowed
- Testing is usually conducted at the end of the development process
There are many traditional methodologies, all based on the core concept of pre-planning the project to guide development. Understanding the most appropriate traditional method for the project is important. If your startup selects a methodology that focuses on planning upfront, you need to make sure you are planning in an appropriate manner.
The following section describes the key traditional methodologies available and begins with the most relevant to startups, the Waterfall model.
Waterfall model
Key Takeaway: The Waterfall model is best suited for startups that have projects with clear, well understood requirements that will not change. Strict documentation and planning prevents flexibility during development when reacting to design problems.
The Waterfall model (also known as linear-sequential life cycle model or cascade model) requires each development stage to be completed and reviewed before starting the next (Figure 2). This model involves a lot of documentation to ensure the team follows the plan and is developing all the requested requirements. This level of documentation may overwhelm startups.
Loops can be introduced to allow the previous stage to be revisited. This allows your startup to conduct product verification.
Advantages:
- New team members can easily join due to the level of documentation and structural design
- Coordination is easy as each stage has an expected result and evaluation process
- Consists of sequential steps that can be easily understood and used by team members
- Has stages that are implemented in sequence
- Becomes easy to determine project costs due to a set schedule and resources that are allocated accordingly
Disadvantages:
- Requirements need to be fully understood at the start of the project
- Identification of new requirements negatively impacts development, increases costs, and delays the timeline
- Limits flexibility during development, and it is difficult to return to the design stage if testing identifies a problem
- Develops a prototype for user feedback at the end of development, not during the process
- Results in high project risk due to limited flexibility
Recommended for the following cases:
- Projects with well understood, clear, and final requirements
- Understood technology that has a concrete repeatable development path (not innovative)
- Short projects with limited chance of additional requirements being requested by the user
- When Subject Matter Experts (SMEs) are readily available within your team to plan out the project before development begins
- Software that provides service to other applications or provides back-end functionality
Prototyping model
Key Takeaway: The prototyping model is best suited for startups that have projects with unclear requirements and, a focus on the user interface. Significant amounts of user involvement commonly increase the project’s duration and overall cost.
The Prototyping model involves the quick creation of a sample of the final product’s capabilities (Figure 3). This model is implemented to validate the user’s requirements and the feasibility of the design before creating the final product. By doing so, your startup ensures that it is producing a product the users want!
Startups commonly use this method to avoid the Waterfall method problem of receiving user feedback only at the end of development. Prototyping is not an independent method. It is rather an approach that startups can use alongside another methodology to improve project success.
Advantages:
- Increases the likelihood of product acceptance due to user involvement during development
- Functional processes of the software are clearly identified and evaluated
- Reduces the risk of software functionality failure
- Requirements can be added throughout the development process
- Detects errors early in development
- Quick user feedback is available and leads to improved solutions
- Easy identification of missing functionality
Disadvantages:
- Changes during the development process results in increased costs
- Excessive involvement of the client can increase the project’s duration
- Large number of changes impact the workflow of the software
- Project complexity may change as the scope of the development project expands
Recommended for the following cases:
- When product requirements are unclear
- When the development software needs to have a lot of interaction with the end users (i.e. online systems and web interfaces)
V-Model
Key Takeaway: The V-model is best suited for startups that have projects with clear, well understood requirements that will not change throughout the project. A large team of highly technical members are required to conduct verification and validation work early in the development process.
The V-model or Verification and Validation model takes the waterfall model one step further with the development and verification stages being performed in parallel (Figure 4). As the software product’s requirements are developed, startups test and integrate them into the final product in parallel. This allows startups to move past subjective terms such as “user friendly”, into more objective and verifiable requirements.
Advantages:
- Consists of sequential steps that team members can easily understand and use
- Focuses on verification and validation early in development, improving the probability of a successful product
- Is a highly-disciplined model with phases completed sequentially
- Each phase has specific deliverables and associated review process to ensure easier management
- Consists of proactive defect testing
- Can be used in large projects with multiple teams, contractors, and sub-contractors
- Project management can track the progress of the project accurately
Disadvantages:
- Increased verification work is not recommended for long projects due to potential timeline delays
- Complex and object-oriented projects are not suitable for the methodology as requirements are not fully integrated during the development process
- Requirements cannot change during the development process
- Changes to functions are difficult to implement once the software reaches the testing stage
- Generates a prototype late in the development process
- Does not handle concurrent events easily
Recommended for the following cases:
- Software that provides service to other applications or provides back-end functionality
- Small projects with requirements that are clearly defined and fixed
- When SMEs are readily available within your team to provide support to the project
Rapid application development (RAD) model
Key Takeaway: The rapid application development model is best suited for startups that have projects with a tight deadline. This model is highly dependent upon the team’s technical knowledge and collaboration efforts to succeed.
The Rapid Application Development (RAD) model is designed to improve the practicality of a startup’s development process by highlighting the participation of the end-user (Figure 5). This method uses prototyping to allow for iterative development. It also promotes a collaborative atmosphere through stakeholder participation. Prototyping cycles are completed over long, drawn-out development and testing cycles.
Advantages:
- Encourages and prioritizes feedback from client to allow for improvement
- Decision making is moved to the functional team instead of the project manager
- Flexible system that allows for requirement changes
- Improves review cycle productivity
- Reduces development time
- Increases productivity with fewer people involved
- Integration is a part of the project from the beginning
Disadvantages:
- Highly dependent upon the team for the model’s success
- Requires highly skilled personnel to handle the model’s complexities
- Not appropriate for small-budgeted projects
- Requires strong team collaboration
- Not suitable for large teams due to the quick turnaround required
- Suitable only for projects that have a small development time
- Creates a complex development process that is difficult to manage
- Requires projects to be modularized to allow for the quick turnaround of project stages
Recommended for the following cases:
- Best suited for software that provides a visual interface to the end-user
- When you have a pool of users that can give consistent and reliable feedback
- When you have a tight deadline to produce the product
Spiral model
Key Takeaway: The Spiral model is best suited for startups with projects that are high risk, and will require frequent updates once available to users. This model is complex and requires all team members to strictly follow it to ensure success.
The Spiral model, a risk-driven development process, is shaped as a spiral, rather than a sequence of activities (Figure 6). Startups combine the waterfall and prototyping methods with the introduction of a risk assessment at the start of the process. Your startup cycles through multiple iterations of the spiral until a prototype is created that can be verified against user requirements.
Advantages:
- Reduces risk with early identification and mitigation to prevent later cost increases
- Suitable for use during large and complex projects
- Allows for additional requirements to be added later
- Suitable for high risk projects with varied business needs
- Integrating the customer into the early stages of development allows them to provide usable feedback and increases their satisfaction
- Development is fast and features are added in a systematic way
Disadvantages:
- Complex development model that requires developers to follow it strictly to ensure success
- Time management is difficult to plan as the number of phases at the start of the project is unknown
- Is a costly method of software development
- Failure during the risk analysis stage of development could damage the whole project
- Not suitable for low-risk projects
- No clear end of the project, so it could continuously extend and never reach completion
- Requires adaptive management that might not be present within the company already
Recommended for the following cases:
- Software that provides service to other applications or provides back-end functionality
- Project that requires frequent releases
- Medium to high-risk projects
- Project that requires a prototype
- Requirements are unclear and complex, and changes may occur at any time
- When long term project commitment is not feasible due to changes in economic priorities
Agile software development methodologies
Key Takeaway: Agile development methodologies allow for flexibility during development and increased user participation. The most popular agile method with startups is the Scrum model.
Agile software development methodologies focus on collaborative development. Users and stakeholders actively guide the development of the product together.
Startups commonly use these methods because of their lean concepts. Agile methodologies minimize unnecessary work and excess documentation. The less time you are working away on paperwork, the more time you can spend creating your software product!
These methodologies accept that uncertainty is a part of software development and trying to control changes is impossible.
Agile software development methodologies are commonly used on projects that are:
- Low budget (less than $200 thousand), encouraging startups to be flexible in their approach in an effort to save money
- Made up of a team with less than ten people
- Conducted by companies with less than 250 employees
Agile methods are likely the best to follow as a startup, as costly mistakes can lead to business failure or financial ruin.
Advantages:
- Ability to rapidly and flexibly respond to change
- Minimal formal processes
- Communication between project team members is encouraged
- Customer feedback is provided throughout the entire development process
- Development is broken into short intervals with frequent software releases
Disadvantages:
- Highly dependent upon the motivation and expertise of the developers
- Difficult for new team members to enter the project
- Need good communication skills to interact with the client regularly
- Difficult to use during large projects due to the emphasis on real-time communication
There are many agile software methodologies available, each allowing for different levels of flexibility during development. Understanding the most appropriate agile method for your startup’s project is important. By understanding these models, you will be able to select the method that is most suitable for your startup’s project, and desired reaction style.
The following section describes the key agile methodologies available and begins with the most relevant to startups, the Scrum model.
Scrum model
Key Takeaway: The scrum model is best suited for startups that have projects with rapidly changing requirements. This model involves an intense project lifecycle which requires technical experts, more than novices, to use successfully.
The scrum model is one of the most widely used agile software development approaches by startups (Figure 7). The model is built on the assumption that the development process is unpredictable, and that the requirements could, and should, be changed during the process.
Startups can use this model to quickly develop software through a series of iterations. Daily scrum meetings, that the user can attend, are held to ensure that development is controlled and tracked.
Advantages:
- Decision making is in the hands of the development team
- Limits the amount of documentation required
- Divides up large projects into smaller ones so each part can be organized as a scrum of a scrum
- Testing is conducted throughout the process to ensure a high-quality product
Disadvantages:
- Requires substantial resources due to daily scrum meetings and frequent reviews
- Not suitable for large projects that require multiple teams to complete. If multiple teams are required, you need to break the project into smaller scrums to allow for easier decision making within the team.
- Requires a team consisting of experts; novices to the field will struggle keeping up to the fast pace
- Intense project cycle due to frequent changes, product uncertainty, and frequent product delivery
- Requires a high level of communication within the team
Recommended for the following cases:
- Works well for small to medium sized projects
- Software that provides a visual interface to an end-user
- Project teams that are mature and are fully dedicated to the product
Lean agile software development model
Key Takeaway: The lean development model is best suited for startups that have projects with low budgets and time requirements allowing for increased productivity. This model is dependent on the team’s technical knowledge and collaboration efforts to succeed and not lose focus during the project.
The Lean Development methodology emphasizes the creation of effortless manageable software in about a third of the time (Figure 8). Startups complete this by restricting the budget and eliminating waste. Meaning your team does not build features that do not impact the functionality of the final product.
This is done to deliver your product early with minimal functionality. Short iterations throughout the process allow for communication with the user and the flexibility to adapt to any unforeseen risks.
Advantages:
- Lowers the budget and time requirements of the project leading to increased efficiency
- Delivers the final product early
- Increase team empowerment and motivation as team members are involved in the decision-making process
Disadvantages:
- Depends on the cohesiveness and commitment of the development team
- Requires the team to consist of members with complementary technical skills
- Loss of focus due to the excessive flexibility
- Need to know the software requirements at the start and they cannot be altered during the process
Recommended for the following cases:
- Software that provides a visual interface to an end-user
- Small projects with a short timeframe
- Less complex projects
- Projects where the user wants to participate in the development process
Extreme programming (XP) model
Key Takeaway: The Extreme Programming model is best suited for startups that have open office space to allow for rapid communication and collaboration between pairs of people on the team. This model is highly dependent upon the team’s technical knowledge and collaboration efforts to succeed.
Using the Extreme Programming (XP) model, startups develop in several small releases (Figure 9). This allows startups to quickly adapt to requirement changes with a low impact on cost.
Developers work in pairs with a simple design and continuously improve the code based on user feedback. This is done in a consistent style so everyone can understand and improve the code. This model aims to save time, and prevent delays when team members are not present to code the feature themselves. XP is considered the most agile method available within software development.
Advantages:
- Functions are reviewed by the users in order to ensure functionality
- Avoids long scope projects by splitting them into smaller projects
- Increases developer motivation as money is provided following the development of individual working features
- Prevents development lags due to developers working in pairs
- Increases knowledge sharing within the team due to team collaboration
Disadvantages:
- Requires open office space
- Works primarily with small to medium fixed projects due to the team size required
- Lacks an initial design stage which could lead to higher costs later when new, incompatible requirements surface
- Effectiveness is dependent upon the people involved with the project
- Requires frequent meetings (virtual or in-person) with the user that may be costly or repetitive
Recommended for the following cases:
- Software that provides a visual interface to an end-user
- Small projects that consist of small teams that work closely to allow for face-to-face meetings
- Projects involving new technology, as this method can face rapidly-changing and technical requirements
- Teams where the user is already integrated
Crystal methods
Key Takeaway: The crystal methods are best suited for startups that have projects with multiple teams working together to rapidly develop a product. Due to the number of crystal methods available, there can be confusion during the project as the crystal method used is changed when the team size increases.
The Crystal Methods are a family of software development methodologies that are colour-coded to signify the risk to human life (Figure 10). Crystal sapphire is for projects that may involve risk to human life, where crystal clear is for projects without those risks.
Startups use these methods as they are considered very flexible. This is because they are designed as a human-centric project, rather than a feature- or business-centric project.
Startups chose the crystal method’s colour as a result of the number of team members and the project’s environment. Crystal Clear is the most commonly used crystal development methodology by startups when developing a software product field.
Advantages:
- Ensures frequent deliverables in order to identify eventual problems in every stage
- Improves features as discussion into how to perfect the process is encouraged
- Allows for increased communication and encourages knowledge sharing between team members
- Requires a technical environment with automated tests, configuration management, and frequent integration
- Reflection workshop held every week to ensure there is clear communication about the development process
- Is not mutually exclusive to other methodologies
Disadvantages:
- Results in projects that are not straightforward due to the number of crystal methods available. Each method’s principles vary with the size of the team and project
- Management is difficult with geographically different teams due to the constant need to communicate and reflect
- Significant amounts of resources are focused on daily meetings and increased team/user communication. This takes resources away from doing development work
- Participation of users is only gained with incremental releases, instead of throughout the entire development process.
- Planning and development are not dependent upon requirements
Recommended for the following cases:
- Companies that have a very open flow of communication within groups
- Projects that have teams of a fixed size that will not change throughout development
- Projects that are less user interface-focused
Dynamic system development model (DSDM)
Key Takeaway: The dynamic system development model is best suited for startups that have projects with fixed resources and timeline budgets. This model does not have defined practices to handle the scalability of a project later in the development process.
The Dynamic System Development Model (DSDM) is derived from the Rapid Application Development (RAD) model. An iterative and incremental approach is used that focuses on the involvement of the user through the development process (Figure 11).
This is a useful model for startups as it involves fixed resources and time, something that you may be experiencing right now yourself. As a result, functionality requirements are adjusted to meet the deadline. This model is structured so that the development process takes the shortest possible time, and that each delivery contains most of the requirements.
Advantages:
- Rapidly delivers on basic product functionality
- Increases users understanding of the product through user testing during development
- Access to users is easy for the developers
- Complete projects on time reliably
Disadvantages:
- Implementation is costly
- Not suitable for small organizations due to the rapid turnaround required
- No defined practices to handle the scalability of the project
- Requirements are unclear at the start of the project
- Represents a dramatic and disruptive change in company culture
Recommended for the following cases:
- For companies that prioritizes developing quickly, while delivering on time and on budget
- Projects that have fixed budgets and timeline
- Products that need to enter the market quickly
Feature driven development (FDD) model
Key Takeaway: The feature driven development model is best suited for startups that have projects with multiple teams working together to rapidly develop a product. This model is not recommended for a single developer, and requires lead developers in order to closely monitor feature development.
The Feature Driven Development (FDD) model organizes development around creating features. These features are small defined projects within the larger project (Figure 12).
FDD focuses on serving companies with many teams working on a project based on object-oriented technology. Due to its multi-team nature, this is a commonly used agile method by startups.
The FDD model uses short-iteration processes to ensure that features are presented to the user quickly (e.g. every two weeks a new feature is presented). As a result, startups focus on the most important user features first.
Advantages:
- Allows for rapid development through its five-step process
- Leverages pre-defined development standards so teams can move quickly
- Allows larger teams to move products forward with continuous success
- Can be scaled to large projects
- Enables the production of tangible results every two weeks
Disadvantages:
- Not suitable for small organizations due to the rapid turnaround required
- Depends on the lead developers as the process needs to be monitored through every phase
- Requires the client to have clearly identified and prioritized features
- Leads to confusion due to the lack of documentation
Recommended for the following cases:
- Large companies conducting development work
- Large-scale software development projects
- Companies that have a very top-down decision-making process
How to select your software development methodology
Key Takeaway: Selecting a software development methodology is a critical stage in the development process. Make sure your startup evaluates organizational, project, and team characteristics before deciding upon a development methodology.
The selection of a software development methodology is an important step when launching your software startup. Your startup must select and follow this methodology from start to finish.
Changing the model partway through the process is difficult. Changing the process ends up confusing everyone on the team, causing potential development delays. This is especially not advised for startups due to the financial and timeline impact of methodology change.
Many industry leaders believe the main reason for project failure is the result of an inappropriate method being used during development. Project failure could be due to the product not being delivered on time or within budget. It could also fail because it does not provide value to the user.
Evaluate different development models based on organizational, project, and team characteristics. This prevents your startups’ selection from being biased by the literature or the recommendations of others.
Characteristics to be evaluated during software development methodology selection
Your startup can create a stellar product by focusing on your project’s specific situation. The following are key characteristics that should be evaluated during the development methodology selection process:
Team characteristics
- Size of the team – Choose a methodology that has shown success when used by a team the same size as yours.
- Team roles – Teams that contain members with several unique roles (i.e. project manager, programmers, designer, technical facilitator, etc.) may require a methodology that is more traditional, based on the organizational structure of your startup.
- Team experience – Agile methodologies depend on highly experienced team members, whereas more traditional methodologies can include novice developers successfully. Look at your development team and determine the ratio of differently skilled team members. Also do not forget to look at the experience level of the leadership team to make sure they can successfully manage a more flexible project structure.
- Management style within the company – If your startup is structured in a top-down manner, team decision making would be difficult, thus preventing most agile development methods from fully succeeding.
Project characteristics
- Project size – Certain methodologies are structured in a way that only works for small projects with a quick turnaround.
- Project complexity – Projects that are highly complex require a more agile development process to allow for adaption to any difficulties that arise throughout development.
- Project risk – Agile software development methodologies are best suited for projects that are high risk due to the consistent cycles of client feedback.
- Project budget – If needed choose a model that focuses on staying within budget, rather than methodologies that allow for increased flexibility because this usually increases the cost of the project.
- Project’s requirements – Traditional methodologies demand that the software requirements be known at the start or the project. More agile methods allow for startups to change the requirements easily throughout the development process.
- Number of mandated reviews – If your startup wants a lot of user feedback during the development process, a traditional methodology is not suitable. In traditional methodologies, the user is not usually given a product to review until the product is fully developed.
Communication requirements
- Geographical location of the team – Some methodologies require frequent communication between team members. This can be difficult if your startup is spread out over different work areas, let alone if they are in different geographical locations.
- Customer accessibility – The selected methodology may require constant feedback from the user. You need to ensure that your startup has users readily available and committed to providing you this feedback.
External project factors
- Market stability – If the market that your software product is entering is constantly evolving, a more agile methodology should be selected. This will allow for increased flexibility during the development process
- Industry requirements – If the industry your product will enter requires adherence to strict regulations, more traditional methodologies may be better suited. This is due to the significant amounts of documentation required.
- Quality assurance procedure in place – If your startup has a fully developed Quality Assurance (QA) system in place, an agile software development process is suitable. This is because a fully developed QA system allows for continuous testing to ensure there is a fully functioning and verified product produced at the end of development.
Can’t decide? Use multiple software development methodologies
As an alternative to selecting one specific methodology, startups can use multiple methodologies on the same project (aka. hybrid methodologies). This, however, is not advisable for startups.
Using multiple methodologies can lead to project management issues. Your startup could also waste resources and time determining what method you at specific times. Companies that choose to go the hybrid route commonly have a medium budget, a highly critical project, and a small team.
Importance of selecting a software development methodology
The development methodology selection process has been found to have a direct impact on the following:
- The amount of testing required, and
- Customer satisfaction, which directly impacts your business’ welfare
As a result, the development methodology selection process should be prioritized by yourself and other members of your startup during the development process in order to create a stellar product.
Use the following SDM selection decision tree, created by the Altitude Accelerator, to get an idea of what methodology you should look at in detail first (Figure 13). This should help you when you are selecting the SDM suitable for your startup’s software development project.
Conclusion: Traditional and agile software development methodologies
There are a variety of software development methodologies available that startups can use to manage the development process. Each method varies in the amount of pre-planning, flexibility and in-development testing required during development.
At the start of every new development project, startups need to evaluate their team and project based on several criteria to determine which methodology is most suitable. Specifically, companies should focus on the individual attributes of the team (i.e. technical skills, communication capabilities, etc.). This is because the team members themselves have a significant influence on the quality of the product produced.
One key thing to keep in mind is that no methodology is the perfect fit for all types of software development projects. So just because a methodology worked with a past project, does not mean that it will be successful during your startup’s next development project.
As you move forward and begin the development of your software, remember to take the learnings from this article with you. Discuss the different development methodologies with your team, and find the one that works best for your project. Get everyone involved in the process so the team collaboration begins early to ensure the success of your project.
Lessons learned on choosing between software development methods
Congratulations! You have now learned about a number of different software development methodologies. After reading this article you should have learned the following key learnings:
- The importance of selecting an appropriate development methodology for your software product.
- Traditional software development methodologies are the most plan-focused development methodologies. These methods are predictive in nature.
- Agile software development methodologies are adaptive in nature and are highly flexible.
- The most popular traditional software development methodology is the Waterfall Method.
- The Scrum Method is the most popular agile software development methodology.
- Your startup needs to review team, project, and organization characteristics when selecting a development methodology.
- All projects are unique so make sure to select the most appropriate one for each development project.
<– Back to: “How to Create Software: Development Techniques to Learn”
