Create the Virtuous Cycle in your Applications

Building great applications is not just about technology, but the mindset you have. Plan, build, and deliver successful applications that continue to improve and increase in value over time.

Download the report

This report outlines the primary guidelines and patterns you need for building modern web applications, including when and where to apply technologies involved in the process.

Author Ron Northcutt helps software architects, developers, and IT leaders understand the underlying cycles at play, including how to evaluate solutions available today and in the future. 

Once you know how to properly view problems, you’ll learn how to apply Headless, Hybrid, and Low Code in the context of the proper mindset.

The result is the ability to plan, build, and deliver successful applications that continue to improve and increase in value.

Understanding the

Core Concepts

The core concepts in the report define the framework that helps you build better applications.

Software Crisis

The term software crisis was coined at the first NATO Software Engineering Conference in 1968 in Germany when the attendees gathered to discuss the new concept of “software engineering” and were surprised to learn that similar issues were plaguing them all.

They used “software crisis” to describe the common problem.

Vicious Circle

When an application is trapped in the vicious circle, most attempts to extend or improve the project actually only exacerbate the underlying problems. 

Everything done to advance or extend the application leads to greater problems like increasing technical debt, bugs, poor performance, and slower delivery times.

Eventually, the application must be decommissioned or replaced.

Component Based Design

The solution to the software crisis is component-based design.

Component-based design emphasizes the separation of concerns in terms of application functionality.

These components may be services, objects, functions, or other logical pieces in a system, but the concept remains the same.


Virtuous Cycle

With proper component-based design, we can create workflows that are optimized for more efficient development.

Applications can become faster, more performant, and less error-prone over time.

They’re also easier to maintain, and we naturally develop the ability to pay down technical debt or simply avoid it altogether.

The secret is to invest in developing your mindset. Everything else will flow naturally from there.

Ron Northcutt Director of Technical Marketing

Component-Based Design

The solution to the "software crisis" is component based design. Ideally, the components in a composable system should be:

  • Modular:  Good components can be added, removed, or swapped out with ease.
  • Independent: Components should be as independent as possible.
  • Stateless: Components should treat each request or interaction as an independent transaction, regardless of previous interactions.
  • Reusable: If a component is modular, independent, and stateless, then it will also be reusable as well. 

In a truly composable architecture, you can take any component out and replace it without impact on the rest of the system.

Guidelines to

Creating the Virtuous Cycle

Separation of Concerns

This is a design principle that divides an application into distinct sections

Keep it Simple

The most resilient systems tend to be very simple, and so needless complexity should be avoided

Single Responsibility Principle

Every component in a modular system should focus on its own part of the whole.

Think of the User

This includes not only the end user experience (UX) for the application, but also the future developer experience (DX)

Don't Repeat Yourself

A general rule of thumb is that if you are building something more than once, then it needs to be standardized and reusable.


Suppress some of the complexity from the user and maintain a simpler interface that gives the user what they need.


Ensure that your software is flexible enough to work in a variety of situations.

Perfect is the Enemy of Good

Focus on creating the virtuous cycle and allow good results to become great results.

Open Source

One of the fastest ways to build applications is by utilizing open source technology.

Comment Your Code

Documentation describes how the code is expected to work, how to use it, and often why certain choices were made


Adopt consistent standards across the project, including basic things like code formatting and commenting conventions.

Incremental Develoment

Starting simply and focusing on the fundamentals ensures that the project can continue to grow and evolve over time

Creating the Virtuous Cycle with Headless, Hybrid, and Low Code

The Principles of Successful Modern Web Apps