Developer experience is a systems design problem, not a culture problem. Platform engineering reduces cognitive load from 12 concepts to 3 for common tasks. Here's the LOAD assessment framework.
Three years ago, I watched one of our best backend engineers spend an entire day trying to set up a new microservice. Not building the business logic. Just the infrastructure: Kubernetes manifests, CI pipeline, monitoring dashboards, database provisioning, secret management, and service mesh configuration. She knew exactly what feature she wanted to build. The platform wouldn't let her build it without first becoming a part-time infrastructure engineer.
That day cost the company about $800 in her salary. Multiply that by 40 engineers, each setting up services 3-4 times per quarter, and we were burning $384K-$512K annually at that setup rate on repetitive infrastructure tasks that had nothing to do with our product. That's when I became a platform engineering convert.
# The Contrarian Take: Developer Experience Is an Engineering Problem, Not a Culture Problem
Most companies treat developer experience as a cultural initiative. They run surveys, hold town halls, and create Slack channels for feedback. That's the equivalent of asking hospital patients how they feel about their paperwork instead of reducing the paperwork.
Developer experience is a systems design problem. The reason your engineers are frustrated isn't that they have bad attitudes. It's that your platform imposes unnecessary cognitive load on every task. Fix the system, and the experience fixes itself.
I measure cognitive load in a specific way: the number of concepts an engineer must hold in working memory to complete a task. This is a practical task inventory. Miller's memory experiments do not establish seven tools or concepts as a universal deployment-task threshold.[1]
Here's the cognitive load for deploying a new service at the company I described above:
Task: Deploy a new microservice
Concepts required:
1. Kubernetes deployment manifests
2. Kubernetes service and ingress configuration
3. Helm chart structure and values
4. CI pipeline YAML syntax (GitHub Actions)
5. Docker multi-stage build optimization
6. Secret management (Vault integration)
7. Database provisioning (Terraform)
8. Monitoring setup (Prometheus + Grafana)
9. Service mesh configuration (Istio)
10. Log aggregation setup (ELK)
11. Health check and readiness probe design
12. Network policy configuration
Task inventory: 12 concepts (no universal seven-concept threshold)
No wonder it took a full day. And that's for a senior engineer who already knew most of these tools. For a mid-level engineer, add 2-3 more concepts for each unfamiliar tool.
Platform engineering creates an internal developer platform (IDP) that abstracts away infrastructure complexity. The goal isn't to hide infrastructure. It's to provide sensible defaults with escape hatches. The developer productivity guide provides the broader measurement context. Identify repetitive work through the toil assessment. Separate local and delivery friction with inner and outer loops.[2]
Every common task should have a "golden path": a pre-built, opinionated, well-tested way to do it. Engineers who follow the golden path get fast results. Engineers who need to deviate can, but they accept the additional complexity consciously.
The illustrative platform spec requires a custom controller, templates or other automation to generate the Kubernetes, CI, monitoring and database configuration. The platform team maintains that implementation and the product team supplies the requested inputs.
Figure 1. The platform must implement the automation behind its interface.
I track platform effectiveness with a metric I call "Concepts to Ship" (CTS): the number of distinct concepts an engineer needs to understand to complete a common task.
Task
CTS Before Platform
CTS After Platform
Reduction
Deploy new service
12
3
75%
Add database table
6
2
67%
Set up monitoring
8
1
88%
Configure CI pipeline
5
0 (automatic)
100%
Manage secrets
4
1
75%
After building the platform, the "deploy new service" task went from a full day to 45 minutes. Not because the infrastructure was simpler. Because the complexity was managed by the platform instead of by each individual engineer.
Start with templates for your most common service types. Don't try to abstract everything. Start with the 2-3 patterns that cover 80% of new services.[3]
typescript
// A service template generatorinterface ServiceTemplate { name: string; type: 'api' | 'worker' | 'cron' | 'event-consumer'; language: 'typescript' | 'python' | 'go'; database?: 'postgres' | 'redis' | 'none'; messaging?: 'kafka' | 'sqs' | 'none';}function generateService(template: ServiceTemplate): void { // Generate project structure generateProjectScaffold(template); // Generate CI pipeline generateCIPipeline(template); // Generate Kubernetes manifests generateK8sManifests(template); // Generate monitoring configuration generateMonitoringConfig(template); // Generate README with golden path documentation generateReadme(template);}// Usage: one command to create a production-ready service// npx create-service --name=payment-processor --type=api --db=postgres
A single place where engineers can see all their services, their health, their dependencies, and their documentation. This is where the cognitive load reduction compounds.[4]
Key features of an effective developer portal:
Service catalog: Every service, its owner, its status, its dependencies
Golden path docs: "How to do X" for every common task, with copy-paste examples
Environment status: Are staging/production healthy? Is CI green?
Self-service actions: Provision a database, create a new service, request access
Use this to prioritize what your platform should tackle first:
L - List all tasks engineers perform that aren't writing business logic. Categorize them: infrastructure, CI/CD, observability, testing, deployment, security.
O - Observe frequency and pain. For each task, track how often it happens and how long it takes. Multiply to get total time cost. Survey engineers to add a pain rating (1-5).
A - Automate the top 5. Sort by (frequency x time x pain) and inspect the highest-scoring tasks. Measure the share of work those tasks represent in your own team before choosing the automation scope.
D - Deliver incrementally. Ship a usable platform in 4 weeks. Iterate based on adoption data, not feature requests. Track "Concepts to Ship" for each common task and drive it down quarter over quarter.
Figure 2. Prioritise a repeated task and inspect whether the golden path helps.
Platform engineering isn't about building cool infrastructure tools. It's about measuring the cognitive load your platform imposes on engineers and systematically reducing it. Every concept you remove from an engineer's working memory is a concept they can replace with business logic.
The companies shipping fastest in 2026 aren't the ones with the best engineers. They're the ones whose platforms let good engineers focus on what they were hired to do: solve business problems, not infrastructure puzzles.
Frequently asked questions
What is an internal developer platform?
An internal developer platform presents shared capabilities through interfaces that suit its users. It can combine service templates, infrastructure, documentation and operational tools. Its value depends on whether teams can complete their actual work more effectively.
Is a developer portal enough to create a platform?
A portal is one possible interface to platform capabilities. It still needs useful underlying services, ownership and support. Start with the task developers need to complete, then choose the interface that makes the capability accessible.
Does Miller's law set a seven-concept deployment limit?
The number of tools or concepts in a task is a practical inventory, not a calibrated measure of working-memory capacity. Use it to locate friction, then check task time and developer feedback. It cannot establish a universal error threshold at seven concepts.
How should platform work be prioritised?
List repeated tasks, observe their frequency and duration, and ask developers where the friction occurs. The article's LOAD method combines these observations into a proposed priority order. Validate the choice through adoption and the effect on the task.
A 3-tier succession planning framework for engineering orgs, with a 90-day sprint for accelerating candidates from potential to ready. Based on succession plans built at 4 companies.
The CTO's real job in product development isn't attending every meeting or making every technical call. It's connecting feasibility, viability, and capacity while letting EMs handle the day-to-day.
Four years of data from a fully remote engineering team across 4 time zones. Specific metrics on productivity, retention, and onboarding with the frameworks that actually worked.
Small frictions cost more than big blockers. 47 micro-frictions consume 96 minutes per engineer per day. Here's the TAX Return framework for finding and eliminating the developer productivity tax.
A structured 30-60-90 day framework for handling engineering underperformance. Based on 14 real cases with a 64% success rate, starting with diagnosis before intervention.
Engineers spend 38% of their time on repetitive, automatable work. Here's a toil audit process that identifies where time disappears and a framework for systematic elimination with measurable ROI.