Platforms: Build Abstractions, not Illusions • Gregor Hohpe • GOTO 2025
Gregor Hohpe explains the critical role of platforms in managing the growing cognitive load on developers due to complex distributed systems. He contrasts platforms, driven by "economies of speed" and fostering innovation through diversity, with traditional IT services and oversimplified abstractions that create dangerous illusions. Hohpe emphasizes building platforms that provide intuitive, domain-specific abstractions to solve real business problems, rather than just repackaging existing cloud services.
Gregor Hohpe reflects on two decades of building complex distributed systems, drawing parallels between the evolution of technology and human interaction. He highlights that while we push technology, technology also pushes back when it becomes too complex, leading to increased cognitive load on developers. The “shift left” movement, intended to streamline the software delivery lifecycle, has ironically piled up responsibilities on developers, requiring them to be experts in business analysis, domain-driven design, security, and operations, alongside writing code. This elevated cognitive load necessitates solutions to make technology more manageable.
Hohpe positions platforms as a crucial solution to this challenge, moving beyond traditional “economies of scale” (doing things once to save cost) to “economies of speed” (doing things once to accelerate delivery). Historically, common base layers like libraries and operating systems were driven by scale. However, modern platforms, akin to the automotive industry’s platform strategy, prioritize speed and innovation. He introduces the concept of a “double pyramid” model: a broad, economical base (like car chassis or cloud infrastructure) supporting a diverse and innovative top layer (many car models or various cloud applications). A true platform enables users to build things the creators didn’t anticipate, fostering innovation rather than stifling it by trying to anticipate all needs, a pitfall of the narrow-tipped “pyramid” model (e.g., the “Cadillac Cimarron effect” of rebranding without true innovation).
Platforms differ fundamentally from traditional IT services. While IT services focus on harmonization and controlled change through tickets, platforms emphasize speed, self-service, and enablement, aiming to eliminate themselves as bottlenecks. Hohpe notes the paradox of infrastructure teams being both ideal (due to deep technical knowledge) and problematic (due to a traditional, service-oriented mindset) candidates for building platform teams, underscoring the need for a cultural shift towards customer-centric enablement.
He argues that effective platforms enable organizations to overcome past constraints, moving beyond the false dichotomy of choosing between standardization (leading to slowness) and innovation (leading to chaos). Platforms achieve “innovation through harmonization,” where well-designed standards (like HTTP or the A4 paper size) don’t restrict creativity but instead free up cognitive resources to focus on actual innovation. The value of a platform is best understood not through static diagrams but by its ability to reduce friction and accelerate movement. Hohpe likens effective platform guidance to “lane assist” or the self-centering design of train wheels, providing low-friction steering rather than relying on “guardrails,” which represent emergency failure points indicating a project is already off track.
The core challenge lies in building meaningful abstractions without creating dangerous illusions. Engineers often struggle with abstraction, tending to expose too much underlying detail (e.g., “piston, crankshaft, gear, wheel assembly” instead of “automobile”). He criticizes cloud providers’ “abstractions” that merely compose existing service names (e.g., SQS, Lambda) without truly simplifying the underlying mental model, acting more as convenience than genuine cognitive load reduction. Hohpe warns against “sane defaults” that hide critical parameters, as they don’t remove inherent complexity but rather obscure it, leading to surprises (the “jigsaw puzzle” analogy). He emphasizes that platforms should strive to make inherently complex systems intuitive, not falsely simple, as stripping away essential properties creates illusions that leak and fail under stress (e.g., treating a remote procedure call like a local one). True abstractions introduce a new, purpose-driven vocabulary (like “accelerator” instead of “gas pedal”) that survives implementation changes and is exemplified by operating systems’ file stream abstraction. To build platforms that cloud providers cannot, organizations must infuse them with deep business domain understanding, offering services specific to their regulatory, data, or process needs (e.g., a PII-compliant database service), thereby creating unique value by operating in the business-technical domain.
Finally, Hohpe addresses the role of generative AI, concluding that even LLMs recognize the continued human need for good API design, abstractions, and logical structure. He warns against trusting superficial appearances, much like the “impossible object” illusion, encouraging critical examination of what truly lies beneath the surface.