Stitched Stacks, No-Code, Low-Code, and Custom Software
Well before AI app builders emerged, organizations launching digital programs faced decisions about both the product itself and the operational infrastructure needed to support it. Teams in industries such as digital health, insurance, industrial IoT, logistics, property management, and education have been building digital programs for much longer. The emergence of AI app builders, discussed in Insight Article,
has dramatically changed the conversation. Nevertheless, AI is only one of several approaches to building software and operating a program.
Common approaches have included stitched stacks, no-code platforms, low-code platforms, and custom software. Each offers a different balance of speed, flexibility, ownership, complexity, and operational responsibility. Understanding these tradeoffs is more important than understanding any individual tool. AI app builders can be viewed as a newer variation within this broader landscape rather than an entirely separate category.
A stitched stack is assembled by connecting specialized tools together. Scheduling, communications, payments, forms, customer management, reporting, and automation are provided by separate tools connected through integrations and workflows. Examples include combinations of tools such as Calendly, Zoom, Stripe, Mailchimp, HubSpot, Airtable, Zapier, and Salesforce connected through integrations and workflows. Teams often choose this approach because it is fast and flexible. They can select best-of-breed solutions for individual functions and replace components as requirements change. Initial investment is often low, and programs can launch quickly.
The tradeoff is operational coordination. As more tools are added, the number of integrations, workflows, operational states, dependencies, and exceptions increases. What begins as a flexible solution can gradually become difficult to coordinate and maintain. Complexity tends to accumulate between systems.
An alternative approach is to choose a no-code platform. No-code platforms provide a unified environment for building and operating applications without traditional software development. User interfaces, workflows, databases, automation, reporting, and administration are often provided within a single platform. Examples include Bubble, AppSheet, Glide, and Softr.
Teams are attracted to no-code because it reduces development effort while providing a more integrated environment than a stitched stack. Programs can often launch quickly without hiring developers or building extensive infrastructure. The tradeoff is that organizations increasingly operate within the assumptions, capabilities, and constraints of the platform itself. As requirements evolve, customization, integrations, and operational flexibility may become constrained by platform boundaries. Complexity tends to accumulate within the platform environment.
A common misconception is that engineering becomes unnecessary in stitched and no-code approaches. In practice, engineering responsibility often shifts rather than disappears. Organizations still make decisions about workflows, integrations, data structures, permissions, security, governance, and operational architecture. While platforms and tools may reduce development effort, poor early decisions can create limitations, technical debt, and operational complexity that become difficult to unwind later.
Low-code platforms occupy a middle ground between no-code platforms and custom software. Like no-code platforms, they provide substantial prebuilt capabilities. Unlike no-code platforms, they allow greater customization through software development. Examples include Microsoft Power Apps, OutSystems, Mendix, and Retool.
Teams often choose low-code platforms because they want more flexibility than no-code provides while avoiding the cost and effort of building everything from scratch. They can accelerate development while retaining greater control over workflows, integrations, and application behavior. The tradeoff is increased technical responsibility. More flexibility requires more implementation effort, more technical expertise, and greater long-term management. Complexity tends to accumulate in customization, configuration, and platform-specific development.
Finally, some teams choose custom software. Custom software is typically built using software frameworks, cloud services, and development tools selected specifically for the organization's requirements. Workflows, user experiences, integrations, data models, and operational requirements can be designed around the business rather than around a platform. Organizations typically choose this path when differentiation, control, or specialized requirements become strategically important. In some cases, existing platforms cannot adequately support the operational model.
Custom software offers maximum flexibility and the ability to adapt the solution as the business evolves. The tradeoff is ownership. Development, maintenance, security, governance, infrastructure, and long-term evolution become the organization's responsibility. Complexity tends to accumulate in development, operations, and lifecycle management.
The following table outlines broad tendencies regarding launch speed, upfront cost, flexibility, and ownership burden for each approach.
| Approach | Launch Speed | Upfront Cost | Flexibility | Ownership Burden |
|---|---|---|---|---|
| Stitched Stack | Fastest | Lowest | Moderate | Low-Moderate |
| No-Code | Fast | Low | Moderate | Moderate |
| Low-Code | Moderate | Moderate | High | Moderate-High |
| Custom Software | Slowest | Highest | Highest | Highest |
Viewed independently, each approach appears to offer distinct advantages and disadvantages. Viewed architecturally, a different pattern emerges. The decision is not whether complexity exists. It is where complexity resides and who is responsible for managing it. Every approach simplifies some challenges while introducing others.
- Stitched stacks reduce initial development effort but increase coordination requirements.
- No-code platforms reduce development effort but introduce platform dependency and constraints.
- Low-code platforms balance acceleration and flexibility but require greater technical management.
- Custom software maximizes control but places responsibility for development and operation on the organization.
Importantly, these approaches are not mutually exclusive. Every technology approach relocates complexity rather than eliminating it. A program may begin with a stitched stack, introduce a no-code platform, add low-code capabilities, and eventually incorporate custom software as requirements evolve. This pattern appears across operationally complex digital environments. The technologies differ. The underlying decisions remain similar.
Teams often evaluate technology approaches based primarily on launch requirements. Speed, features, cost, and implementation effort are important considerations. However, these factors rarely determine smooth operational evolution by themselves. Programs evolve. New workflows emerge. New services are introduced. New integrations become necessary. Operational requirements grow more complex.
Each approach has characteristic areas where complexity tends to accumulate:
- Stitched stacks in coordination across systems
- No-code platforms in platform constraints and dependencies
- Low-code platforms in customization and technical management
- Custom software in ownership and lifecycle management
A more useful question is which form of complexity best aligns with an organization's objectives, resources, operational model, and expected future evolution.
