The history of software development is littered with different methodologies all targeting the same golden triangle: fast, high quality and inexpensive.
Rapid application development emerged in the 1980s as an alternative to the slow and inflexible waterfall model. Waterfall places its focus on planning the best path forward from the start, which can make it challenging and time consuming to address anything that might have been missed in the planning phase.
While waterfall was the slow and lumbering dinosaur in the world of software development, RAD was its far more dynamic successor. Rather than trying to get everything right from the outset, RAD emphasizes rapid prototyping and frequent iterations based on user input. Today, we might also call it agile – and RAD is often considered the precursor to Agile.
In this article, we'll break down the nuts and bolts of rapid application development, how low code enables RAD and explain how 8base, as a low-code platform, supports RAD at all tiers of software development – UI, logic, and data.
Rapid Application Development is a methodology for building software quickly by focusing less on planning and more on adapting. The building process of the RAD methodology starts by loosely defining the requirements and building the first working version as fast as possible. After that, Rapid Application Development focuses on making changes based on user feedback.
The RAD model typically includes the following steps as outlined by James Martin:
Rather than producing a detailed list of specifications, requirements planning in the Rapid Application Development model involves sitting down with stakeholders to produce a set of broad requirements based on business outcomes. Because the requirements are kept broad, it allows the engineering team to problem solve throughout the development cycle.
Without a rigid set of requirements, software developers instead focus on developing different prototypes as quickly as they can. The prototypes are made to showcase different features and functionalities, and they are shared with stakeholders for feedback.
It's important to note here that the rapid prototyping in the second phase is only meant to showcase features. The final product is only created during the deployment stage, when stakeholders have approved the functionality of the final product.
In the rapid construction phase, the software development team takes their learnings from the user design phase and build a working system from their model. They continue to take feedback and reviews in this stage, working to address bugs, issues and last-minute stakeholder requests.
The product is released to general availability. The final phase of RAD software development methodology involves scale testing, final debugging and shipping the working system into production before completing technical documentation.
The well-known advantages of RAD include better user feedback, greater process effectiveness, improved quality, reduced risk, better on-time/on-budget completion, and faster (more effective) development. Much like Agile, the goal is to get the user involved early and often to use their feedback to build a better product. This process continues until the finished version of the product is reached.
To say it another way, the risk of reaching the end of development (i.e., the finished product) and users “not liking the results” is much lower with RAD. Remember, the users and their feedback were baked in the process all the time. And it's unlikely they will completely change their mind at the last step.
Since low-code tools accelerate the software development process and improve developer productivity–more time, money, and focus can be placed on user feedback and building software right the first time. Low code plus RAD equals speed, high quality feedback, lower costs, and more.
You can use rapid application development whenever you have a project where user feedback is the most crucial factor.
Ambiguity and lack of clarity are normal for most new products–because neither you nor the end users know what exactly they want or need. So you can't design and build something well without getting user feedback. And, users can't give you feedback without seeing and trying out what you built.
It's a chicken and egg problem which is best solved using the rapid application development software methodology:
So you're slowly taking steps in the right direction. Before you know it, you have a finished product that users already like and approve of.
If you're developing mission-critical software, you should definitely avoid RAD methodology. For example, if you're developing autopilot software for the aircraft industry, you don't want to be "testing" things out.
Additionally, there are software projects oriented around extract-transform-load (ETL) processes where no end-users exist. Here, the key acceptance criteria is the source and target applications.
In other words, if there is no end-user who needs to buy, accept, or use the software, RAD might not be the best approach. Rapid application development certainly has its time and place, but it is not appropriate for every use.
When a RAD approach is used, the risk of reaching the end of development (i.e., the finished product) and users not liking it is very low. Launching a product without user feedback is perhaps the largest risk a product leader and development team can take. Many large companies as well as startups have failed because of a lack of user input and feedback.
With RAD, your users and their feedback are continuous. As you get the user feedback, your product is slowly converging towards what the users want or need. And it's unlikely they will completely change their mind at the last step. It simply doesn't happen.
Because of this, the time and capital risks are very low because you have constant course correction from the users. This prevents you from going very far and investing a lot of resources in the wrong direction.
But what happens if you marry RAD with low-code technology?
Whatever quality, speed, or other benefit you achieved with RAD, you'll now get an additional 3-5X increase in software development productivity. This is largely because some low-code platforms generate all the boilerplate code for you. It makes the entire development team more efficient and effective.
In short, low-code technology allows you to focus on the most valuable parts of the app and automate everything else.
There have been many RAD tools that focus on UI, others focus on logic, and another set focus on data stores.
With 8base, you can apply rapid application development to all tiers–UI, logic, and data.
At the UI tier, 8base App Builder gives developers the tools to configure components, properties, styling, events, state, routing, queries, and more. This provides a more productive platform to accomplish RAD.
Importantly, 8base lets developers “drop into code” and write JavaScript and TypeScript wherever they want or need to. Unlike other low code tools, 8base doesn’t prevent the developer from coding anywhere they need. In fact, you can say that 8base allows developers to spend more time coding (and doing what they love) and less time on the mundane, repetitive boilerplate.
At the data tier, 8base provides a simple, user-friendly tool to create data models. There is no need to be a DBA or know SQL if you want to build a high-scale, ACID-compliant database. (In fact, front end engineers become full stack engineers after only a few hours of training.) With a RAD mindset, 8base makes it simple to configure tables, fields, and relationships with clicks.
As the data model is created, 8base automatically creates 1000s of options for GraphQL queries across all tables, relationships, and fields–this includes all CRUD operations and subscriptions for both single record queries and lists. In addition, support for aggregations, counts, grouping, pagination, and other operations are auto-generated. And, you can pass arguments or use variables, aliases, fragments, and more. Without needing to write this code, RAD becomes much faster.
The logic tier also supports RAD. Not only does 8base give developers auto-generated and auto-documented GraphQL, 8base provides developers with out-of-the-box access to the whole stack. You also don’t have to build resolvers, webhooks, triggers, or tasks (chron) functions from scratch–8base provides scaffolding for integrating your code. There are also configuration options for button clicks, navigation, state, data triggers, external systems, and more. While these speed development and reduce bugs, they are all extensible with code.
When it comes to provisioning and deployment, these are both push-button experiences, which saves a lot of time on a RAD project. In addition, your new app migrates to a high-scale, “CTO-approved,” serverless architecture.
When doing RAD with a low code tool like 8base, the benefits multiply beyond what each does alone.
We're excited about helping you achieve amazing results.
