Deploy Apps with an Internal Developer Platform – Part 2

In the cloud-native era, the emergence of platform engineering as a discipline marks a pivotal evolution from traditional DevOps practices. This evolution underscores the importance of enabling self-service capabilities within software engineering organizations, streamlining the journey from development to deployment. Following the footsteps of platform engineering pioneers, this second installment of our series dives deeper into how internal developer platforms facilitate effortless application deployments. Leveraging tools such as Backstage and ArgoCD, we explore the synergy between development teams and operations, highlighting a GitOps-driven workflow that not only accelerates the development cycle but also seamlessly integrates with the underlying infrastructure provisioned by platform engineers.

If you haven’t caught up with Part 1, where we lay the groundwork by automating GKE clusters, I highly recommend starting there to grasp the full scope of building an internal developer platform.


Video Chapters

  • 00:00 Introduction

  • 00:38 Diagram Explanation

  • 02:40 Backstage and Crossplane Courses Announcement

  • 03:07 Main Demo Starts

  • 07:43 Make Changes to the App

  • 08:47 GO API Template

  • 11:13 GitHub Actions Workflow

  • 12:42 Clean-Up

  • 14:28 Backstage is Complex

  • 15:14 Closing Remarks


Join the Newsletter and get FREE access to the Source Code

The Developer’s Journey to Deployment

Leveraging internal developer portals like Backstage simplifies the deployment process, turning what used to be a ticket-filled back-and-forth into a streamlined, self-service operation. As developers, we kickstart our journey by invoking a GO API template—courtesy of our platform engineering team—within Backstage, our internal platform.

From Template to Deployment: A Behind-the-Scenes Look


While the magic unfolds seamlessly from a developer’s perspective, it’s essential to understand the platform engineering tools and processes working tirelessly behind the scenes:

  1. Initiating the Workflow: Selecting the GO API template in Backstage triggers a GitHub Actions workflow.

    Go API Template
  2. ArgoCD Takes the Stage: The workflow cues ArgoCD within our Kubernetes infrastructure to create an application. We can see that the application is ready in the Backstage UI below.

  3. The Final Deployment: ArgoCD deploys the GO API into the GKE cluster, previously set up by our platform engineers, culminating in a fully deployed application and a new repository for further development.

    Go API Running in the Cluster

And if you go to our URL we can see the API running:

API App running

This GitOps-driven workflow exemplifies how internal developer platforms and portals are reshaping software engineering organizations, fostering a culture where developer self-service thrives.

Demo Highlights: Enabling Developer Self-Service

Our demo walks through the entire process, from selecting the GO API template in Backstage to the successful deployment of the application. Here are the key takeaways:

  • Simplifying Developer Workflows: By enabling self-service capabilities, developers can deploy applications without navigating the traditional ticket-based system.

  • Continuous Deployment Made Easy: With the newly created repository, any subsequent changes pushed by developers automatically trigger deployments through ArgoCD, keeping the application up-to-date.

  • Visibility and Control: Developers gain insights into their application’s deployment status directly within Backstage, further bridging the gap between development and operations.

Enabling Self-Service Capabilities for Accelerated Product Delivery

The concept of self-service in platform engineering has revolutionized how development teams interact with infrastructure provisioning and deployment processes. By designing and building toolchains that emphasize ‘golden paths’—predefined best practices and workflows—platform engineering teams provide developers with useful and differentiated capabilities. These capabilities, encapsulated within internal developer portals, significantly enhance developer productivity by offering straightforward access to complex infrastructure tasks in a self-service manner.

Platform Engineers Bind Development and Operations

This series underscores the crucial role of platform engineering teams in uniting development and operations teams. Through the creation of templates and workflows that foster self-service capabilities, these teams enable developers to concentrate on innovation instead of getting bogged down by the intricacies of infrastructure.

Distinguishing Internal Developer Portals from Internal Developer Platforms

Internal developer portals such as Backstage serve as a cornerstone for enabling self-service capabilities within an engineering organization. They act as a single point of access to a multitude of tools, services, and documentation, effectively reducing cognitive load on developers. Through gathering feedback from internal customers, platform teams can continuously refine these portals, ensuring they meet the evolving needs of product teams and adhere to service level agreements (SLAs).

On the other hand, Internal Developer Platforms (IDPs) provide a more comprehensive suite of integrated tools and services designed to automate and simplify the entire software development lifecycle. Platforms such as Spinnaker for continuous delivery, Terraform for infrastructure as code, and ArgoCD for Kubernetes-based deployments exemplify how IDPs serve to bridge the gap between code commit and production deployment, encapsulating the tools and services found in developer portals into cohesive, scalable environments.

Both internal developer portals and platforms are instrumental in modern software engineering, yet they serve distinct purposes. Portals primarily focus on accessibility and navigation of tools and services, while platforms offer the underlying mechanisms and workflows that automate and expedite the development and deployment processes. Together, they form the backbone of a highly efficient, agile, and developer-centric infrastructure, enabling seamless collaboration between development and operations teams and fostering a culture of innovation.

Building Internal Developer Platforms

The journey of building internal developer platforms involves more than just assembling a collection of tools; it requires a holistic strategy focused on integrating these tools into a cohesive, integrated product. This integration ensures that from infrastructure provisioning to application deployment, every aspect of the software delivery lifecycle is optimized for efficiency and scalability.

User Research in Action

User research plays a critical role in understanding the needs of internal customers. By engaging with developers directly, platform teams can identify pain points in the development process and deploy solutions that truly enhance the developer experience. This collaborative approach not only increases developer productivity but also fosters a product mindset across the platform team.

Designing Golden Paths

Golden paths, or recommended best practices, guide development teams through the most efficient processes for building and deploying applications. By establishing these paths, platform engineers provide clear guidance that accelerates product teams’ delivery, ensuring that applications are developed, tested, and deployed in alignment with the organization’s standards for quality and security.

The Role of Platform Teams in the DevOps Evolution

As the discipline of platform engineering continues to mature, its role in the evolution of DevOps practices becomes increasingly significant. Platform teams, composed of dedicated product teams and platform engineers, are at the forefront of this evolution, driving the development of internal platforms that embody the principles of the cloud-native era. Their work enables developers to deliver software with greater speed and flexibility, marking a significant leap forward in how engineering organizations approach software delivery.

Looking Forward: The Future of Platform Engineering

As we conclude Part 2, it’s clear that the essence of successful platform teams lies in their ability to enable developer self-service, thereby enhancing productivity and fostering innovation. The journey through building an Internal Developer Platform with GitOps not only demonstrates the technical feasibility but also highlights the cultural shift towards more autonomous and empowered engineering teams.

Stay tuned for future discussions, where we’ll dive deeper into specific platform engineering tools, share more platform engineering examples, and perhaps take you behind the scenes of a platform engineering conference.

We’d love to hear from you: What specific tools or examples would you like to see explored in our future posts? Are there any challenges you’re facing in your platform engineering journey that you’d like us to address? Perhaps there’s an emerging tool or concept you’ve heard about and are curious to see in action? Share your thoughts, questions, and suggestions in the comments below or connect with us through social media. Your input will help shape our upcoming content, ensuring it aligns with your interests and addresses the topics most relevant to you.

Thank you for joining us on this transformative exploration of internal developer platforms. Together, we’re not just deploying applications; we’re crafting the future of platform engineering. Stay tuned, and let’s continue to shape this exciting field together.

Suggested Reading

Leave a Comment

Your email address will not be published. Required fields are marked *

Scroll to Top