Internal Developer Platform (IDP) Design

Platform Engineering for Integration Teams

Introduction

An Internal Developer Platform (IDP) provides self-service capabilities for developers to provision, configure, and deploy integration resources. By abstracting complexity and providing golden paths, IDPs enable teams to move faster while maintaining standards. This guide covers designing an IDP for Azure integration workloads.

This comprehensive guide covers:

Platform components — What to include
Self-service capabilities — Enabling autonomy
Developer experience — Making it easy to use
Governance — Maintaining standards
Implementation — Building the platform

Platform Components

IDP Architecture

┌─────────────────────────────────────────────────────────────────────┐
│                  INTERNAL DEVELOPER PLATFORM                        │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│   DEVELOPER INTERFACE                                               │
│   ────────────────────                                              │
│   ┌─────────────┐  ┌─────────────┐  ┌─────────────┐                 │
│   │   Portal    │  │   CLI       │  │   GitOps    │                 │
│   │   (Web UI)  │  │             │  │             │                 │
│   └─────────────┘  └─────────────┘  └─────────────┘                 │
│                                                                     │
│         ↓                    ↓                    ↓                 │
│   ┌─────────────────────────────────────────────────────────┐       │
│   │              PLATFORM LAYER                             │       │
│   │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐      │       │
│   │  │ Service     │  │ Environment │  │  Resource   │      │       │
│   │  │ Catalog     │  │ Manager     │  │ Provisioner │      │       │
│   │  └─────────────┘  └─────────────┘  └─────────────┘      │       │
│   └─────────────────────────────────────────────────────────┘       │
│                                                                     │
│         ↓                    ↓                    ↓                 │
│   ┌─────────────────────────────────────────────────────────┐       │
│   │              BACKEND SERVICES                           │       │
│   │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐      │       │
│   │  │ Azure       │  │ Terraform   │  │ CI/CD       │      │       │
│   │  │ Resource    │  │ Cloud       │  │ Pipelines   │      │       │
│   │  │ Manager     │  │ Provider    │  │             │      │       │
│   │  └─────────────┘  └─────────────┘  └─────────────┘      │       │
│   └─────────────────────────────────────────────────────────┘       │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Catalog Structure

{
  "serviceCatalog": {
    "integrationServices": [
      {
        "name": "Azure Function",
        "description": "Serverless compute for event-driven workloads",
        "provider": "Azure",
        "tiers": ["Consumption", "Premium", "Dedicated"],
        "configurable": [
          "Runtime stack",
          "Memory size",
          "Scaling limits",
          "VNET integration"
        ],
        "defaults": {
          "runtime": ".NET 8",
          "memory": "256MB",
          "scaling": "Auto"
        }
      },
      {
        "name": "Service Bus",
        "description": "Enterprise messaging",
        "provider": "Azure",
        "tiers": ["Basic", "Standard", "Premium"],
        "configurable": [
          "Queues vs Topics",
          "Sessions",
          "Dead lettering",
          "Partitions"
        ],
        "defaults": {
          "tier": "Standard",
          "maxDeliveryCount": 3,
          "ttl": "7 days"
        }
      },
      {
        "name": "Logic App",
        "description": "No-code workflow automation",
        "provider": "Azure",
        "configurable": [
          "Triggers",
          "Actions",
          "Connections"
        ]
      }
    ]
  }
}

Self-Service Capabilities

Environment Provisioning

# Developer requests environment via portal/CLI
# idp-cli provision environment --name staging --team payments

environment "staging" {
  subscription = "platform-dev"
  resource_group = "rg-payments-staging"

  resources = {
    function_app = {
      name = "order-processor"
      runtime = "dotnet"
      plan = "Premium"
    }

    service_bus = {
      name = "orders"
      tier = "Standard"
      queues = ["orders", "dead-letter"]
    }

    storage = {
      name = "paymentstaging"
      tier = "Standard"
    }
  }

  tags = {
    team = "payments"
    environment = "staging"
    cost_center = "12345"
  }
}

GitOps Integration

{
  "gitOps": {
    "repository": "github.com/company/infrastructure",
    "structure": {
      "environments": {
        "dev": "/envs/dev/",
        "staging": "/envs/staging/",
        "prod": "/envs/prod/"
      },
      "modules": "/modules/",
      "components": "/components/"
    },
    "workflow": {
      "developer": "Updates YAML in feature branch",
      "validation": "CI validates and shows plan",
      "approval": "PR review by team lead",
      "deployment": "Auto-merge triggers apply"
    }
  }
}

Developer Experience

Golden Paths

┌─────────────────────────────────────────────────────────────────────┐
│                  GOLDEN PATHS                                       │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│   INTEGRATION FLOW DEPLOYMENT                                       │
│   ───────────────────────────                                       │
│   1. Developer creates integration-flow.yaml                        │
│   2. IDP validates configuration                                    │
│   3. Pipeline deploys to environment                                │
│   4. Automatic testing runs                                         │
│   5. Promotion to next environment                                  │
│   Time: ~10 minutes                                                 │
│                                                                     │
│   SERVICE BUS TOPIC SETUP                                           │
│   ────────────────────────                                          │
│   1. Developer requests via portal                                  │
│   2. IDP validates permissions                                      │
│   3. Creates namespace and topics                                   │
│   4. Configures access for consumer apps                            │
│   Time: ~5 minutes                                                  │
│                                                                     │
│   ENVIRONMENT CREATION                                              │
│   ─────────────────────                                             │
│   1. Developer submits request with team approval                   │
│   2. IDP provisions resources from module library                   │
│   3. Connects to shared services                                    │
│   4. Configures monitoring and alerts                               │
│   Time: ~30 minutes                                                 │
│                                                                     │
└───────────────────────────────────────────────────────────────-─────┘

Governance

Policy Enforcement

{
  "governance": {
    "policies": [
      {
        "name": "Required tags",
        "enforcement": "All resources must have team, cost_center tags"
      },
      {
        "name": "Approved SKUs",
        "enforcement": "Function apps must use Premium in production"
      },
      {
        "name": "Network isolation",
        "enforcement": "Production must use private endpoints"
      },
      {
        "name": "Retention",
        "enforcement": "Storage must have lifecycle policy"
      }
    ],
    "enforcement": {
      "buildTime": "Prevent invalid configs from merging",
      "deployTime": "Block non-compliant deployments",
      "runtime": "Detect and alert on violations"
    }
  }
}

Best Practices

Implementation Checklist

Practice	Description
Start simple	Begin with commonly needed services
Iterate	Add capabilities based on feedback
Provide templates	Golden paths for common patterns
Enable self-service	Reduce platform team bottleneck
Maintain governance	Prevent configuration drift
Measure adoption	Track platform usage