I'm building a new dev platform and want tooling recommendations

Absolutely — if you’re building a new dev platform, the best tooling choices depend a lot on what “platform” means for you:

• Internal developer platform (IDP) for app teams
• Platform for your product engineers to deploy services
• PaaS / control plane for customers to build on
• ML/data platform
• Multi-tenant SaaS with developer extensibility

If you want, I can tailor recommendations to your exact architecture. For now, here’s a practical, opinionated stack by platform layer.

1) Core platform backbone

Infrastructure provisioning

• Terraform — still the default for most teams
• Pulumi — if you want real programming languages and stronger abstraction
• Crossplane — if you want Kubernetes-native control planes and composability

Recommendation:

• Use Terraform for fast adoption and ecosystem maturity
• Use Crossplane if your platform is deeply Kubernetes-centered and you want self-service APIs

Configuration and secrets

• Vault — strong standard for secrets and dynamic credentials
• AWS Secrets Manager / GCP Secret Manager / Azure Key Vault — simpler if you’re cloud-native and want managed-only
• SOPS + age — great for GitOps-managed encrypted config

Identity and access

• Okta / Auth0 / Entra ID for workforce identity
• Keycloak if you want self-hosted
• OPA / Open Policy Agent or Cedar for policy enforcement
• Dex if you need OIDC federation in Kubernetes-heavy environments

2) Deployment and runtime

Containers and orchestration

• Kubernetes — most flexible for a dev platform
• ECS/Fargate — simpler if you’re AWS-first and don’t need full K8s complexity
• Nomad — lighter alternative if you value simplicity

GitOps / deployment automation

• Argo CD — best-known GitOps controller
• FluxCD — also strong, more modular
• Argo Rollouts — for progressive delivery, canaries, blue/green

Release management

• Helm — still common for packaging
• Kustomize — better for overlays and env-specific patches
• Carvel — worth evaluating if you want more opinionated packaging workflows

3) Developer experience tooling

Developer portal

• Backstage — the default starting point for internal developer portals
• Port or Cortex — managed alternatives with quicker setup
• Roadie — Backstage-as-a-service

Recommendation:

• Choose Backstage if you want flexibility and can own the maintenance
• Choose Port/Cortex if you want faster time-to-value

Local development environments

• Dev Containers (VS Code / devcontainer spec)
• Tilt or Skaffold for Kubernetes-native inner loop
• Telepresence if developers need to connect local code to remote clusters
• Docker Compose for simpler services

CLI / platform SDK

• Build a single platform CLI early
• Use OpenAPI/Swagger, gRPC/protobuf, or JSON Schema to generate clients and validate resources

4) CI/CD and build system

CI

• GitHub Actions — great default if you’re on GitHub
• Buildkite — strong for complex pipelines and scale
• GitLab CI — if you’re all-in on GitLab
• CircleCI — still solid, though less compelling for new builds

Build acceleration

• Bazel — excellent for large monorepos and reproducible builds
• Pants — good Python/TS/Go-centric alternative
• Nx/Turborepo — great for JS/TS monorepos

Recommendation:

• If you’re early-stage: use GitHub Actions + standard build tooling
• If you have a large monorepo or many languages: seriously evaluate Bazel

5) Observability and operations

Metrics / logs / traces

• OpenTelemetry — must-have foundation
• Prometheus + Grafana — metrics standard
• Loki — logs if you’re in Grafana ecosystem
• Tempo / Jaeger — tracing
• Elastic / OpenSearch — if full-text log/search matters

Alerting / incident management

• PagerDuty or Opsgenie
• Statuspage for external status
• Incident.io for process/runbooks

Error monitoring

• Sentry — excellent for app-level errors and performance

6) Platform control plane and API layer

If you’re creating a true platform, this layer matters most.

API design

• gRPC + protobuf for service-to-service
• REST + OpenAPI for public/admin APIs
• GraphQL only if you truly need client-driven aggregation

Resource modeling

• Use CRDs if Kubernetes-native
• Use a typed resource schema elsewhere:
  • OpenAPI
  • JSON Schema
  • protobuf-backed resource definitions

Workflow/orchestration

• Temporal — excellent for durable workflows and async orchestration
• Argo Workflows — good for K8s-native batch workflows
• Dagster / Prefect — if data workflow is your focus

Recommendation:

• Use Temporal for platform workflows, provisioning, approvals, retries, and long-running tasks

7) Security and supply chain

• Trivy — container/image/IaC scanning
• Syft + Grype — SBOM + vuln scanning
• Cosign — artifact signing
• SLSA practices for build provenance
• Dependabot or Renovate — dependency updates
• gitleaks — secret scanning
• Falco — runtime security detection

8) Data layer and analytics

If your platform needs usage analytics or metering:

• ClickHouse — excellent for event and usage analytics
• Postgres — default transactional store
• Kafka / Redpanda — event streaming
• dbt — analytics transformations
• Airbyte — ingestion/connectors

9) My default recommended stack by maturity

If you’re early-stage and want speed

• GitHub Actions
• Terraform
• Kubernetes or ECS
• Argo CD
• Backstage
• Vault or cloud secrets manager
• OpenTelemetry + Prometheus + Grafana
• Sentry
• Temporal
• Renovate + Trivy + Cosign

If you’re building a serious internal platform

• Terraform + Crossplane
• Kubernetes
• Argo CD + Argo Rollouts
• Backstage
• Vault
• OpenTelemetry + Grafana stack
• Temporal
• OPA
• Renovate, Trivy, Syft/Grype, Cosign
• Platform CLI + API-first resources

10) Biggest recommendation overall

Don’t start by picking every tool. Start with these platform primitives:

1. A clear resource model
   Everything should map to typed platform resources: app, env, service, database, secret, policy, workflow, deployment.

2. A self-service control plane
   This is your platform product. CLI + portal + API.

3. Golden paths
   Make the default path easy: create service → get repo → CI → deploy → observability → secrets → alerts.

4. Policy and guardrails
   Bake in standards instead of relying on docs.

5. Developer experience metrics
   Measure lead time, deployment frequency, MTTR, onboarding time, and self-service success rate.

If you want, I can also give you:

• a minimal MVP tool stack
• a Kubernetes-first reference architecture
• a tooling matrix by layer
• or a build-vs-buy recommendation for each component.