Platform Orchestrators: The missing middle of Internal Developer Platforms? | Daniel Bryant

Summary

This presentation delves into the principles of designing effective platforms for developers, emphasizing the importance of clear abstractions, Progressive Disclosure, and robust API design. The speaker highlights the need to build platforms that accommodate diverse user interfaces (CLI, UI, API) and operate as internal products, with a focus on increasing speed, efficiency, and reducing risk. The talk also explores lifecycle management, the role of orchestration tools like CTIC, and measuring platform success through key performance indicators. It underscores the necessity of understanding user needs and continuously evolving the platform to foster adoption and scalability.

Takeaways

• 😀 Designing platform abstractions and clear APIs is critical for platform success, ensuring each layer has a specific role and does not exceed its scope.
• 😀 Progressive Disclosure is a powerful concept that helps reduce user anxiety by simplifying complex configurations and making advanced features accessible as users grow in expertise.
• 😀 Designing platforms with multiple interfaces (UI, CLI, API) is essential to meet the diverse preferences and skill sets of different users and teams.
• 😀 Automation is a key driver for efficiency in platform design, and APIs provide the power needed to achieve scalable and reusable automation.
• 😀 Building platforms as products rather than just technical tools helps align business goals with developer needs, increasing adoption and long-term success.
• 😀 Tool selection should be based on trade-offs. Open-source tools like Crossplane, Terraform, and others have different strengths and are best suited for different stages or goals in platform design.
• 😀 Clear boundaries between different platform layers (application, orchestration, and infrastructure) lead to more manageable and scalable platforms, with proper API management at each layer.
• 😀 Reusability and modularity are vital to the long-term success of platforms. Writing reusable 'aspects' (like security checks) and encouraging their contribution can significantly reduce maintenance overhead and accelerate innovation.
• 😀 Focusing on both leading (e.g., platform adoption rates) and lagging indicators (e.g., app retention rates) is crucial to measure platform success and understand areas for improvement.
• 😀 The 'missing middle' in platform design refers to the lack of orchestration tools that bridge the gap between the high-level abstractions and the low-level configurations, which can hinder scaling operations efficiently.

Q & A

What is the concept of Progressive Disclosure, and why is it important in platform design?

Progressive Disclosure is a design principle where you initially provide a simple interface to users, hiding complexity at first. As users gain more expertise or need more functionality, more complex options are gradually revealed. This approach is important in platform design as it prevents overwhelming new users with complexity, while still providing advanced users with the power to perform more complex tasks when needed.

How do clear abstractions and APIs contribute to successful platform architecture?

Clear abstractions and APIs are essential for platform architecture because they allow different layers of the system to remain focused on specific tasks, hiding complexity. This enables easier maintenance, more flexibility for users, and clearer separation of concerns, which ultimately leads to a more scalable and user-friendly platform.

What is meant by the 'missing middle' in platform development?

The 'missing middle' refers to the gap between highly abstracted platforms and complex, low-level configurations that developers struggle to manage. It often appears when platforms provide too many abstractions or require deep technical expertise. Identifying and addressing this gap is key to ensuring platforms are both powerful and accessible.

Why is it important to design platforms with a focus on both UI, CLI, and API?

Designing platforms to support multiple interfaces (UI, CLI, API) ensures that developers and users can interact with the platform in the way that suits their workflow and preferences. For instance, some users may prefer the simplicity of a UI, while others may favor the automation and power of a CLI or API. Meeting users where they are is critical for platform adoption and flexibility.

What role do APIs play in automating platform management?

APIs are central to automating platform management because they allow for programmatic control over platform components, facilitating integration and automation of tasks like deployment, scaling, and configuration management. APIs enable teams to automate repetitive tasks, integrate with other systems, and scale their infrastructure more efficiently.

How do you differentiate between product-focused and implementation-focused platforms?

Product-focused platforms are designed with the user experience and business goals in mind, aiming to deliver a valuable and efficient solution for end-users. Implementation-focused platforms, on the other hand, prioritize technical and architectural decisions, with less emphasis on user-facing features and more focus on backend functionality and integration.

What are some key performance indicators (KPIs) that measure platform success?

Key performance indicators for platform success include adoption rates, onboarding times, time to first meaningful action (e.g., deployment or feature use), and return on investment (ROI). These KPIs help track whether the platform is enabling users to be more efficient, whether they are returning to the platform, and if they are realizing value from the system.

What are some tools mentioned that help with platform orchestration, and what are their uses?

Tools like Crossplane, Backstage, Argo, and Kubernetes are mentioned as part of the ecosystem for platform orchestration. Crossplane helps with infrastructure management, Backstage is used for creating developer portals, Argo is focused on CI/CD processes, and Kubernetes is widely used for container orchestration. These tools support various layers of platform development, from user-facing interfaces to backend orchestration and automation.

Why is it important to treat a platform as a product within an organization?

Treating a platform as a product ensures that platform teams prioritize user needs, business goals, and continuous improvement. By adopting a product mindset, platform teams can focus on creating value, measuring success through relevant KPIs, and iterating on the platform to meet evolving requirements. This approach fosters greater adoption and long-term sustainability.

How can platforms be designed for composability, and why is this beneficial?

Platforms can be designed for composability by building modular, reusable components that can be easily combined and recombined to meet different needs. This approach allows teams to manage, upgrade, and scale platform components more efficiently. It also enables collaboration between different teams (e.g., security, platform, and development teams) to create shared components that can be reused across the platform.