The 3 phases and 12 stages of the no-code development lifecycle

The no-code development lifecycle consists of 3 phases, which in turn include 4 stages each. Phases represent logically distinct domains of a no-code project and happen in a sequential manner, while stages within a phase are more interconnected and can even happen in parallel in certain circumstances.

The 3 phases are the following:

• Design phase: covers defining the business requirements and success criteria of your app, envisioning its broad design, and scoping the MVP.
• Go-Live phase: addresses building and releasing your initial app.
• Everyday Delivery phase: covers the process of measuring the performance, delivering ongoing enhancements, and managing the evolution of your no-code app.

The 12 stages, which are touched upon below, but fully explored in the No-Code Playbook, can therefore be easier understood as 3 logical blocks: stages 1-4, stages 5-8, and stages 9-12.

Stage 1: Business Use Case

The Business Use Case stage can be the most important part of the entire lifecycle because it helps identify your target and how you will measure success. Resist the temptation to skip or rush through this process. Instead, thoughtfully identify as clear of a definition as possible — this will act as the “true North” that will keep the team on track throughout the project and the evolution of the app.

At its most simplistic level, the business use case should define the following: no-code stakeholder, business process, process use case(s), process consistency, and success criteria.

As you start turning the business use case into a high-level architecture for your application, you’ll need to start making some key choices. How do you pick the right components? These are tackled at stage 2.

Stage 2: Options Analysis

In traditional software development, options analysis is, typically, a choice between “buy” and “build.” In most enterprises, there is a mix of both as each option helps optimize for slightly different outcomes. Packaged applications (“buy”) help you accelerate your time to market but may constrain you to fit within a defined process or UX provided by the application vendor. Custom development (“build”) will help you meet even the most demanding customer requirements, but the process will take you longer as it comes with the inherent risks of building from scratch.

When you use no-code development for building software, you can have the best of both worlds in many cases. On one side, you can accelerate your time to market by using configuration tools, prebuilt components, and templates. On the other side, you can also meet and exceed even demanding enterprise-grade requirements by leveraging the extensibility of the platform.

Therefore, in the no-code development, the basic idea is to strive for “composability” — using as many available no-code building blocks as possible and further customize them for perfect fit. Usually, prebuilt components – as well as connectors to third-party solutions – are provided by the no-code vendor or its community via a marketplace.

Now that you’ve selected the right approach to your solution components, you’re ready to start actively designing. What no-code design best practices should be followed and how “deep” do you go? This is the purpose of stage 3.

Stage 3: Design and Prototyping

Instead of putting the functional requirements into an intermediate document and then translating it into code at a later stage, the functional requirements and design process in no-code development are much more efficient and streamlined. A no-code architect should define an application with all the needed parameters using the no-code tools (e.g., fields, dashboards, UX/UI, and workflows) and make changes on the fly when presenting and evolving a prototype. Unlike traditional prototyping, with no-code, you’re building the software itself. It’s not a simple low-fidelity wireframe or some type of “throw-away” clickable prototype — you’re building a working iteration of the final application.

The Design and Prototyping stage should be performed using the no-code platform visual tools themselves. This allows for rapid ideation cycles where the design effort more directly and immediately can be tested with end users.

If used correctly, this powerful approach to no-code design will help you prepare for the “unknown future” by allowing you to experiment, collect feedback, and iterate rapidly to ensure alignment with the business vision. As soon as you’ve validated this vision, you can change gears in stage 4 and begin to define the successful steps that will get you to your destination.

Stage 4: Project Assignment

The Project Assignment stage defines the target scope of your no-code app that you will be building in the next 4 stages. At a high level, it includes the following activities:

• Decomposing the business use case into smaller use cases.
• Selecting and confirming which of these use cases will be included in the initial Go-Live scope.
• Ensuring that the scope aligns with any timeline constraints established by the business function.
• Defining the necessary roles and participants in the project.

Preparation for enablement of the release (including identification of power users, scheduling of governance checks, planning enablement, selecting the right set of environments, etc.).

When you focus on perfection and completeness, you risk trying to “boil the ocean” by including too much in the first release. It’s key to mitigate this risk by staying “on target” and focusing on an MVP that delivers “just enough” features to test value early and adopt an incremental approach to adding functionality over time. Yet, you can’t build incomplete feature sets — each step of the journey must still be incrementally valuable, usable, and delightful. That is the art of defining the MVP release, which is the goal of stage 5.

Stage 5: Prototype to MVP

The Prototype to MVP stage starts by focusing on the rapid delivery of the initial Go-Live release, which was defined by the prior Project Assignment stage.

Unlike traditional software development, we aren’t starting from scratch. First, no-code platforms provide a significant amount of the underlying infrastructure. This allows you to focus on the business functionality that you want to build, rather than worrying about building technical and application frameworks. You also accelerate the process by “inheriting” the working prototype that was built during the earlier Design and Prototyping stage. We start by extending the available prototype, which allows us to save a lot of time and minimize the risks of misalignment.

The most important thing to take away is to stay focused on releasing the MVP as quickly as possible. It doesn’t have to be perfect — it shouldn’t be because the quest to find perfection will distract you from the core mission. Instead, it would help if you embraced the power and speed of no-code platforms — take advantage of them by adopting an efficient, lean, and iterative approach that fully uses its unique strengths in accelerating development. Now, concurrent with the MVP development, you should also be collecting feedback.

Stage 6: Feedback Loop

Instead of feedback only happening at one point in time, we collect constant interactions and approvals by the stakeholder to ensure alignment throughout the development process. This may happen as often as a few times a day! So, this stage actually runs concurrently with the prior “Prototype-to-MVP” stage.

In no-code development, gathering feedback should be an ongoing and continual process. This allows you to respond to feedback more readily and ensures alignment with stakeholder needs. You won’t know for certain what the user wants unless you ask — and the sooner (and more often) you ask, the more successful you will be!

You’ve finished development and revised it with a continuous feedback loop — you’re almost ready to release. However, before you deploy, it’s important to ensure the app has met the required governance and compliance reviews.

Stage 7: Governance checks

This is a critical step of the review process to ensure your app has successfully passed the applicable checklists and is ready for production release. This typically includes reviewing the following:

External compliance checklists to assess compliance with external laws, guidelines, or regulations imposed by government institutions, industries, and organizations.

Internal compliance checklists imposed by internal audit teams or committees to enforce adherence to rules, regulations, and practices as defined by internal policies and access controls.

Security checklists to protect your corporate information resources from external or internal attacks.

Data governance checks to assess how sensitive corporate data is managed and secured.

Stage 8: First release

This stage is where the application is released to production to end users. The release process is typically straightforward in modern no-code platforms — they adopt the “continuous deployment” philosophy and use automation to deploy features quickly and seamlessly across environments in an on-demand fashion. However, there will be variations in the number and type of environments as well as in the specific steps of the continuous deployment workflow. The scale and complexity of the release will be driven by the Application Matrix – a tool for application complexity assessment used throughout the no-code development lifecycle – which helps define the appropriate level of sophistication needed. Finally, there are associated operational/support readiness activities and end user onboarding/enablement activities that will be needed for the first release of the application.

The previous stages of the No-code Lifecycle have ensured the application has met all of the stakeholder, user, and governance requirements. However, there are still some final steps to prepare the business function to use the application, including the following:

• Documentation and application guides
• Deployment
• Validating environments
• Final user acceptance
• Support and monitoring
• User onboarding and enablement

As end users are onboarded, there is also usually some associated enablement activity required to support effective adoption. Besides traditional training and enablement techniques, it is recommended to adopt a model of continuously retraining the users based on the “Everyday Delivery” approach. Also, it is suggested to use certifications and testing to confirm their ability to fully utilize the system specifically for complex enterprise-grade apps.

Stage 9: Feedback collection

Feedback is an important stage as this is the first time when the no-code app will likely start having daily usage by real end users who are fully vested in the app working because it enables them to perform their job function. They will let you know when the app isn’t working right. View all types of feedback — even if it is critical — as a good thing because it will help you continue to improve and enhance the app.

Feedback collection is essential to evolving your no-code app, but it’s important that you’re gathering the right feedback — through a combination of stakeholder, user, and system feedback — while taking a varied approach to input collection.

Stage 10: Incremental improvements

It’s tempting to focus on achieving perfection all at once — but that is an unachievable goal. Instead of trying to address all requirements, expectations, and suggestions, it’s better to strive to continuously improve daily based on real-world feedback. This allows you to make progress toward your goal while also continuously learning and adapting along the way.

In this stage of the lifecycle, you should focus on the following simple steps:

• Analyze and decompose use cases
• Prioritize and approve micro-use cases
• Review design considerations
• Build/test enhancements
• Review governance checks

Stage 11: Everyday Delivery

One of the key principles behind Agile is the notion of continuous delivery of value. Yet, too often in traditional software development, we get stuck in having to conform to defined release sprints or iterations. A key differentiation of the no-code approach is accelerated time-to-market. The modern platform capabilities empower no-code teams to deliver sufficient outcomes daily to end users.

The spirit of the Everyday Delivery stage is striving to provide rapid updates to the end user and maintaining a high velocity and ongoing improvement cycle. The deployment can be based on a specific feature or set of features without a need to connect it to a specific sprint deadline or other formal milestones. To establish this mode of continuous delivery, it’s critical to appropriately decompose and scope your work items so that you can rely on the higher degree of deployment automation provided by no-code platforms. This allows for quick, small updates to be pushed to production frequently (perhaps daily) while maintaining higher levels of quality than traditional “big bang” software releases.

Stage 12: Application Audit

Initially, the Application Audit is likely performed by the no-code team and is reported to the no-code stakeholder. However, as the number of no-code apps increases and as you develop more business-critical apps, the audit function generally will become part of the responsibilities of the Center of Excellence, which is an internal team whose mission is to maximize efficiency through consistent adoption of best practices for no-code development across the organization. This will help look across the organization to measure and improve overall levels of efficiency, effectiveness, and business impact. It will also help identify reusability opportunities (a key concept we’ll address shortly). However, regardless of who performs the audit, it’s important not to miss any key steps:

• Auditing app performance
• Auditing feature obsolescence
• Auditing organizational changes
• Auditing governance changes
• Auditing component reusability

These final measurement steps are key to any continuous improvement cycle, and the Application Audit stage ensures that the app stays relevant to the business.

More detailed information can be found in Creatio’s No-Code Playbook.

This blog post is part of a series of posts based on the No-Code Playbook.