Rapid application development (RAD) may be one of the hottest buzzwords of software development right now, but it's not exactly a new concept.
When software architecture and development really kicked off in the 1980s, the leading process followed the model of its older brother, classic architecture, and engineering. Developers spent a bulk of their time on up-front planning scrupulously outlining every detail of each problem. They discussed each goal, opportunity, and outcome before assembling a team, coordinating resources, and starting to build.
It works for construction. But not for software. Code is malleable and ever-changing, a stark contrast to the steel beams and concrete that goes into a building. In software, things move quickly.
After a few years, software engineers and developers caught on. They knew they needed something different and started to create processes more suited to their needs.
Building on his predecessors, James Martin fine-tuned the idea of Rapid Application Development (RAD) in the late 1980s. Software has never been the same.
What is Rapid Application Development?
Rapid application development is a software development approach focusing on rapid prototyping, skipping the traditional arduous and complex planning process. It starts with a very short requirements approach to identify bare bones functionality needs. Then it's off to the races.
Developers jump right into building a first prototype based on a rough agreement. They focus on creating a framework and then piecing together modular components by recycling past work with minor customizations. Or, they use third party components from trusted resources who adhere to industry best practices. The development team then presents this initial version to the client for feedback following a few internal tests. Then they promptly begin the next version of the prototype.
Benefits of Rapid Application Development
1. Innovates the Traditional First Step
The planning process no longer requires months, or worse, years. Instead of painstakingly going over requirements and details with clients, RAD cuts this time-consuming step down by jumping into development sooner.
2. Improves Speed and Flexibility
RAD takes the pain out of shifts in strategy and functionality. You can turn on a dime during your development process without going through several strategy reviews with clients, wasting their time and your developers' time.
3. Kicks Off Show and Tell Sooner
The development process emphasizes short development windows to get an iteration of the product into the customer's hands for review faster. This validates your work and vision more quickly, giving your development team a cyclical confidence boost.
4. Increases Knowledge Gained
RAD also provides clients with more opportunities to provide feedback and keep a project from going too far down the wrong path. Therefore, it also provides them with fewer opportunities to be disappointed and more to increase satisfaction with the end product. Of course, if you're moving in the right direction, your clients will feel more comfortable with the creative control they've given your team and how functionality is unfolding.
5. Enhances Product Usability
The iterative development process makes for a stronger, more successful product with heightened usability for clients and their teams. The many checks and balances involved with each prototype allow clients to point out what they like and don't like, as well as the superfluous and missing functionality, early in the process. This constant improvement boosts software usability early in the game, increasing its potential for success.
6. Builds Meaningful Relationships with Clients
Rapid application development can't take place without increased communication with clients. Constant back-and-forth with clients is part of RAD's foundation. And there's a great side effect - a significant, lasting relationship with each client. These frequent check-ins provide more opportunities to show you care about their businesses.
7. Minimizes Bugs
Testing should take place for each software prototype iteration before it reaches the customer. Meaning - you should catch bugs earlier. This usually details the kinds of major bugs that knock projects completely off-kilter when you think you're ready to deploy.
Rapid application development doesn't just make the project go faster, it reduces the risk of project failure. The loop of constant work, testing, and feedback makes it almost impossible to launch a product that the client doesn't love.
However, the development process isn't without its challenges.
Rapid Application Development Challenges
1. Often Misses the Point
Without the typical rigorous requirements collection phase, you sometimes fail to get all crucial information related to the purpose and goals of the software application. This can lead your development down the wrong path for the first prototype, wasting time, resources, and money. Removing the discovery phase may seem to put you on the fast track at first, but in the long run, can cause a chain reaction of setbacks, putting you further from your deployment goal.
2. Produces Development Jams
In rapid application development, the speed of your team heavily depends on how fast the customer can provide feedback. Sometimes this gets stuck if many departments or business decision-makers are involved, halting an entire project. If this happens with every iteration and prototype, RAD essentially loses its meaning. This is another of shortchanging the initial discovery phase. If you start with a list of customer expectations, you can develop with fewer and less frequent check-ins along the way.
3. Heavily Depends on the Client
A developer can promptly respond to the client, but if more than one business decision maker is involved - an entire internal team or department, for example - the prototype must make the rounds. Meetings and discussions take place. It could be weeks before the development team gets needed comments on their work. This, paired with early miscommunication on specific goals for the solution, can result in more feedback than expected for the development team and wreak havoc on deadlines.
4. Pressures Project Managers
As we make obvious in the point above, clients often need a little prodding to keep communication streamlined. In addition, they need a translator between them and the developer, a role the project manager often falls into. As a result of the increased back and forth in rapid application development, PMs often end up facilitating more two-way communication, explaining feedback to developers and sharing changes in a new prototype with clients. They must stay on top of the constant updates and keep all involved parties informed.
5. Requires a Specific Type of Project
In order for rapid application development to work effectively, you must split up components of a product. You can't build everything at once. If you do, your prototype essentially serves as the finished product. Some projects just can't be split into modules and worked on separately. And keep in mind that "modular" in theory makes sense. But even if you think the software you're building is modular, there can be overlapping parts you hadn't foreseen, gumming up the works. Integration at the end of the project may present new challenges and deployment setbacks.
6. Creates Scalability Problems
The bigger the system under development, the more at risk you put it for scalability issues. The prototypes may work for the current business need, but the future ones could be an entirely different ball game. If you plan on upgrading the software application often and using it for a growing team and/or business, go with a more formal and planned-out strategy. Start with a structured consulting process that includes business analysis and a heavier planning stage.
7. Keeps Deadlines at Arms Length
Because most development teams promise to continue to build prototypes until the client is satisfied, the project end date and budget are often open-ended. This adds quite a bit of stress onto both the development team, who needs to forecast their projects and hours, and the client, who needs to keep the project within budget.
How to Make Rapid Application Development Work:
Rapid application development works better for some projects than others. It’s a great fit for developing user experience-rich consumer-facing mobile applications, where the experience is the product.
However, it often creates immovable obstacles for business applications, as it fails to deliver the predictability organizations need.
If you decide to build with RAD, you need a few things in place:
- Capabilities for incremental delivery: If you can't work on development in pieces, you can't use RAD.
- Clear expectations set with clients: If they've never worked with rapid application developers before, they may expect more collaboration up front and get upset if they don't get it. Ensure they understand what they're getting into before committing to a project. You'll need prompt and comprehensive feedback to improve upon each iteration. Make sure clients understand they must respond quickly with constructive and clear criticism.
- Talented and experienced project managers: Your PM team must speak both languages and keep the client happy while keeping the development team busy. That means constant and clear two-way communication.
- Tight security processes: As iterations flow back and forth between your development team and client, many opportunities arise for malicious attacks and careless data loss alike. Successful rapid application development absolutely requires airtight protection of each prototype version and consequent sensitive client data.
- An evolving project map: Do you need a detailed and solid plan before you jump into development? No, that would defeat the purpose of RAD. However, you need to to see where you've been to plan out your next steps accordingly. You may only create your map at the current pace of development, but it helps you measure your progress. And don't worry - this map will never be linear.
- Highly-skilled developers: Each needs a wide-range of skills to make each phase and iteration move quickly. The more each can do, the faster development moves. If you pigeon-hole your development, it will slow things down as you have to wait until a certain team member's schedule opens up.
- Solid internal knowledge and resources database: The more you can automate, the better rapid application development you can deliver. Start to build a collection of trusted templates, layouts, plugins, design themes, and best practices to build prototypes faster, minimize mistakes, and cut out time-intensive steps.
Delivering the Best of Both Worlds
At Soliant Consulting, our team handles application development differently than described above. We’ve developed an alternative method, a hybrid of rapid development and traditional discovery-heavy development.
As our company name insinuates, we prioritize solving business problems and improving internal efficiency for our clients over fast delivery and deployment. We never completely cut the entire business analysis and discovery process for our clients. It's too crucial to a powerful application at the end of the day. However, we also like to get to work as soon as possible and deliver solutions quickly for our clients.
As a result, we strive to find the middle ground. We don't make clients wait months before starting our first iteration on the modules we can deliver first, but we never start a project without a thorough understanding of its goals first.
Contact our team today to learn more about how our team expedites the consulting phase without cutting corners to deliver finished products sooner.