Developer Self-Service

What is Developer Self-Service?

Developer self-service is a platform engineering practice that allows developers to independently access, manage and deploy the resources and tools they need. By empowering developers to act autonomously, without the direct support of DevOps or IT, self-service minimizes development bottlenecks, improves efficiency, accelerates the pace of development and empowers developers. As a result, organizations can enhance developer productivity and foster a culture of innovation and experimentation, by making it easier to test new ideas with minimal overhead.

An Internal Developer Portal enables developer self-sufficiency through the use of self-service actions with baked-in guardrails. The portal provides developers with access to a software catalog, a central metadata store for everything application-related from CI/CD metadata through cloud resources, Kubernetes, services, and more. In the portal, developers can autonomously provision, terminate and perform day 2 operations on any asset in the software catalog. Self-service actions affect the entities within the software catalog - creating, modifying or deleting them. With Port, all self-service actions are automatically reflected in the software catalog, even when temporary. 

The developer self-service approach leans heavily on automation, Infrastructure as Code (IaC) and CI/CD practices. These ensure that developers can work as independently as possible, while still adhering to organizational policies and standards. This represents a significant shift towards platform engineering, which aims to address problems that development teams have had in being able to build, deploy and manage their own cloud infrastructure, by focusing on collaboration, automation and efficiency.

Types of Developer Self-Service Actions

Developer self-service actions are the processes and tasks developers can initiate and complete on their own. While these can vary between organizations, some common types include:

  • Environment Provisioning - Automatically setting up and configuring development, testing, or production environments, including cloud resources and IaC. This is done with predefined templates or configurations and is often based on tools like Terraform, Ansible and Docker.
  • Scaffolding a New Service or Application - Quickly and easily set up the foundation for a new service. Get a pre-configured starting point that is ready for you to begin building upon. 
  • Deployment - Pushing code to testing or production environments, with tools like Jenkins, GitLab CI and GitHub Actions.
  • Access Management - Requesting and gaining access to necessary resources, like databases, servers, or specific applications, without waiting for manual approval. This is often managed through RBAC systems in IAM solutions.
  • Monitoring and Logging - Setting up and configuring monitoring and logging for applications and services with tools like Prometheus, Grafana, and the ELK Stack (Elasticsearch, Logstash, Kibana). This enables tracking performance, detecting issues early and troubleshooting problems. 
  • Scaling Resources - Scaling CPU, memory and storage on demand. This can be done manually or automatically.
  • Database Management - Creating new databases, modifying schemas, running migrations and more.
  • Feature Flagging - Toggling features on and off without deploying new code, with tools like LaunchDarkly or Split. This facilitates testing in production, A/B testing and gradual feature rollouts.
  • Self-service Analytics - Creating queries and dashboards for insights into application usage, performance metrics, and other data analytics, with tools like Metabase or Redash.
  • Data and ML management - Spinning up notebooks, updating tables and running DAGs for the data pipeline.

Developer Self-Service Actions Best Architecture

To enable self-service, an internal developer platform (which is different from a portal) requires an architecture that allows for developer autonomy, efficiency, automations and scalability. Here are the key components of a self-service software development system architecture, incorporating modern practices and technologies:

  • Control Plane - Resource management of all resources, including applications, infrastructure and services.
  • Control Plane Interface - Managing the control plane.
  • Git - A centralized location for desired states that supports GitOps for control plane updates.
  • Databases - A central location for stateful components with a schema handling method.
  • Secrets Manager - A central location for storing Secrets like passwords.
  • Internal Developer Portal - This is the crucial differentiator for developer self-service. It acts as a user interface for developers to execute processes, store new resources in Git and access the software catalog.
  • CI/CD Pipelines - Automated execution of developer actions.
  • Microservices architecture - Allowing actions to be loosely-coupled from the application, to enable scalability and flexibility.
  • Software Catalog - An up-to-date repository of services, environments and other components.

What is the Best Experience for Developer Self-service?

Developer self-service actions need to empower developers and foster a sense of ownership towards resources, tools, and information. They also need to remove the cognitive load from developers and increase satisfaction. This involves several key components:

  • The ability to provision, terminate and perform day-2 operations.
  • Golden paths that offer intuitive, straightforward routes for developers to achieve desired outcomes with minimal assistance.
  • Guardrails that ensure developer autonomy while maintaining code quality and security standards through automated checks and balances.
  • RBAC to allow developers to access what they need to perform their jobs.
  • A visually appealing and user-friendly interface.

Developer Benefits from a Self-Service Portal

Developer self-service portals empower developers by providing direct access to tools and resources, reducing the need for DevOps and IT assistance. Key benefits of a self service portal include:

  • Autonomy and Ownership -  Developers gain the ability to self-provision resources as needed, without waiting on others or submitting tickets. This autonomy creates ownership and significantly speeds up development iterations, testing and deployments.
  • Resourcefulness - By allowing developers to access, manage and scale resources on-demand, organizations can optimize their use of cloud services and other tools. This reduces waste and improves cost efficiency.
  • Productivity - Developers who move forward autonomously without barriers can accelerate their development processes and deliver higher-quality code while feeling more satisfied. These components increase productivity. 
  • Learning and Innovation - Self-service portals should provide access to the latest technologies and tools. Developers can experiment with new services and frameworks, which fosters a culture of continuous learning and innovation. This not only enhances their skills but also contributes to the development of more advanced, robust applications.
  • Consistency and Quality Standardization - Portals can enforce best practices, standards and organizational policies across development projects. This uniformity helps maintain quality, reduce errors and ensure a standardized approach.
  • Enhanced Security - By centralizing access to resources, self-service portals can consistently enforce security policies on them. This reduces the risk of vulnerabilities and ensures compliance with data protection regulations.

How Does The Developer Self-Service Model Work?

Developer self-service allows developers to choose and work with the tools and resources they need to build and deploy their applications or software solutions. Here's how it typically works:

1. Centralized Platform - A central self-service platform or portal is provided where developers can discover, access and manage various tools and resources. This internal developer portal serves as a centralized location for all their development needs.

2. Software Catalog - The platform hosts a catalog of services, including APIs, libraries, frameworks, and other tools that developers can access and use for development.

3. Self-Service Provisioning - Developers can provision these services themselves directly from the portal, without needing to go through a lengthy approval or ticketing process. This means they can quickly develop or experiment with different tools and technologies without hurdles.

4. Usage Monitoring and Reporting - The self-service platform often includes features for monitoring resource usage, highlighting usage trends and tracking progress. This helps improve the development process and the portal experience.

5. Documentation and Support - Comprehensive documentation and support resources are typically provided alongside each service in the software catalog. This empowers developers to understand how to use the tools effectively and troubleshoot any issues they encounter.

6. Automation and Integration - The platform also offers automation capabilities, allowing developers to trigger workflows that will run their tasks.

Get started with developer self-service here.

Let us walk you through the platform and catalog the assets of your choice.

I’m ready, let’s start