Infrastructure as Code (IaC) has been a cornerstone of DevOps practices for years. It provides a way to define, manage, and version infrastructure configurations through a declarative and reproducible process. However, there’s a growing trend towards UI-based flows in Platform Engineering. Is this shift a step forward, a sideways move, or a potential misstep? Let’s dive into the nuances of this development.

The Appeal of UI-Based Flows

There are several reasons why UI-based infrastructure management tools have gained traction:

  • Accessibility: User-friendly interfaces lower the barrier to entry. Team members without a strong coding background can participate in infrastructure provisioning and management.
  • Speed: UIs often streamline certain tasks, potentially accelerating the onboarding of new team members or making common adjustments faster.
  • Standardization: Well-designed UI-based tools can embed best practices and reduce configuration drift, ensuring consistency throughout an organization.
  • Reduced complexity (sometimes): For straightforward use cases, a visual flow may indeed be simpler to understand and maintain compared to its IaC equivalent.

The IaC Counterargument

IaC proponents would point out the following inherent limitations of UI-based approaches:

  • Limited flexibility: User interfaces, no matter how well-designed, constrain the possibilities compared to the expressiveness of code or configuration languages.
  • Version control: UI-generated configurations can be harder to track in version control systems like Git. This complicates rollbacks, collaboration, and auditing.
  • Hidden complexity: The abstraction layer provided by UIs might obscure underlying details vital for in-depth troubleshooting or complex scenarios.
  • Lock-in potential: UI-based tools often create a tighter dependency on a specific platform or vendor, limiting portability compared to more vendor-agnostic IaC options.

A Hybrid Approach

The reality is that this isn’t a “one vs. the other” situation. Successful Platform Engineering teams often embrace a combination of IaC and UI-based flows, leveraging the strengths of each approach:

  • Use cases as the guide: Employ UIs for frequently repeated tasks, basic configurations, or onboarding less code-oriented team members. Leverage IaC for scenarios requiring maximum customization, intricate logic flows, or integration within complex automation pipelines.
  • Seeking interoperability: Favor tools that bridge the code and visual worlds. The ability to switch between UI-based workflows and their underlying IaC representations mitigates the downsides of both methods.

Factors Influencing Adoption

The degree to which UI-based flows  make sense for your organization depends on several factors:

  • Team skillset: If you have a team full of developers already fluent in IaC, the shift to UIs might feel restrictive. However, a more diverse team could benefit from the accessibility UIs offer.
  • Infrastructure complexity: Managing vast and highly dynamic infrastructure often necessitates the fine-grained control and expressive power of IaC.
  • Compliance requirements: Industries with stringent audit requirements are likely to find code-based IaC more auditable due to its clear version history capabilities.

Conclusion

The rise of UI-based flows isn’t a sign that IaC is dying. Rather, it adds another powerful option to the Platform Engineering toolbox. Instead of an either/or choice, think of it as expanding the set of strategies available. It’s about intelligently choosing the right tool for the job.  The organizations that thrive will cultivate the ability to use IaC and UI-based flows strategically, playing to their respective strengths to deliver efficient and adaptable infrastructure management.