openskills.info
← Solutions Architect career guide

Infrastructure and operations

Solutions Architect timeline

How the field of a Solutions Architect got here: the sourced milestones from every published course of this career, on one axis.

1972 to 2026

289 milestones across 31 courses

  • Core
  • Supporting
  • Specialization

The axis stretches toward recent years, where most milestones fall. Bars count milestones per year; dots are single milestones.

Before 1990

15 milestones

  1. 1972

    Parnas publishes criteria for decomposing systems

    David Parnas framed module decomposition around information hiding, giving architectural boundaries a change-oriented basis.

  2. 1972 Dec

    Information hiding defines a module-decomposition criterion

    Parnas described decomposing modules around design decisions likely to change. The idea made change isolation a concrete architectural concern.

  3. 1976

    Distributed database transaction model published

    A formal model described distributed database transaction processing, establishing the problem of coordinating work across sites. It supplied a basis for later commit and recovery protocols.

  4. 1978

    Gray describes transaction processing foundations

    Jim Gray's notes set out the systems concerns around reliable transaction processing. Commit processing became a distinct recovery and coordination problem rather than only a database API detail.

  5. 1978

    Lamport defines logical clocks and happened-before

    Lamport defined happened-before as a partial order generated by process order and message send and receive. The paper gave distributed systems a way to reason about causality without assuming synchronized physical clocks.

  6. 1978

    Lamport defines logical ordering

    Time, Clocks, and the Ordering of Events in a Distributed System introduced happened-before and logical clocks. It gave distributed programs a way to reason about causal order without one perfect physical clock.

  7. 1982

    The Byzantine Generals Problem formalizes arbitrary faults

    Lamport, Shostak, and Pease described agreement when faulty participants can send conflicting information. The result distinguished arbitrary behavior from ordinary crash failures in protocol design.

  8. 1983

    FLP establishes the asynchronous termination limit

    Fischer, Lynch, and Paterson showed that deterministic consensus cannot guarantee termination in a completely asynchronous system when one process may crash. Practice separates safety guarantees from the timing assumptions needed for progress.

  9. 1985

    FLP establishes an asynchronous liveness boundary

    Fischer, Lynch, and Paterson proved that deterministic consensus cannot guarantee termination in every fully asynchronous execution with one possible crash. Practical protocols therefore state additional timing or liveness assumptions.

  10. 1986 Dec

    R* documents distributed commit processing

    The R* distributed database paper described transaction management and commit protocol performance in a production-oriented distributed system. It made the operational cost of distributed commit a practical design concern.

  11. 1987

    Zachman publishes a framework for information systems architecture

    Zachman's framework organized architecture descriptions by perspectives and interrogatives. It established the need for coordinated enterprise views.

  12. 1987 Dec

    Sagas define compensating transactions

    Garcia-Molina and Salem publish Sagas for long-lived transactions. The paper frames work as independently committed steps with compensations for partial execution.

  13. 1987 Dec

    Sagas introduce compensating transactions

    Garcia-Molina and Salem proposed sagas for long-lived transactions as sequences of smaller transactions with compensating actions. This separated business recovery from holding one long atomic lock boundary.

  14. 1988

    Partial synchrony gives liveness a practical model

    Dwork, Lynch, and Stockmeyer formalized timing models between full synchrony and full asynchrony. Protocols could retain safety while basing eventual progress on bounds that hold only after an unknown stabilization point.

  15. 1989

    Lamport develops the Paxos protocol

    Lamport's Paxos work framed agreement around numbered proposals, promises, and quorum acceptance. It supplied a durable vocabulary for preserving one chosen value across competing rounds.

1990s

18 milestones

  1. 1990

    Paxos presents a protocol for distributed agreement

    Lamport presented the Paxos protocol for reaching agreement among processors. Paxos became a core reference for using quorum overlap to preserve a shared decision despite failures.

  2. 1991

    Graphviz initial public release

    Bell Labs researchers release Graphviz, an open-source graph visualization package that renders DOT language descriptions into diagrams. It establishes the idea that graphs can be defined in text and rendered automatically, predating the diagram-as-code movement by over a decade.

  3. 1991

    X/Open publishes distributed transaction processing reference model

    The X/Open DTP model standardized the vocabulary of application programs, transaction managers, and resource managers. XA made interoperable two-phase commit a deployable integration boundary.

  4. 1992

    Software architecture becomes an explicit research field

    Work on architectural styles and abstractions separated system-level structure from individual program modules. Architecture became a subject that could be described and analyzed directly.

  5. 1993 Apr

    Commercial two-phase commit tradeoffs compared

    Research compared several two-phase commit variations for commercial environments. It highlighted that normal-case optimizations change recovery and logging tradeoffs rather than removing the commit problem.

  6. 1993 Dec

    MQSeries V1 reaches the market

    IBM delivered MQSeries V1 in December 1993. It established store-and-forward messaging as enterprise integration infrastructure.

  7. 1994

    SEI publishes An Introduction to Software Architecture

    The SEI introduction presented architectural representations and styles for reasoning about complex systems. It gave practitioners vocabulary beyond implementation diagrams.

  8. 1995

    The 4+1 view model connects views to scenarios

    Philippe Kruchten described logical, process, development, physical, and scenario views for different architecture concerns.

  10. 1996

    Pattern-Oriented Software Architecture broadens style vocabulary

    Buschmann and colleagues published patterns including layers, pipes and filters, and broker structures.

  11. 1996 Jun

    UML 0.9 published

    The unified modeling effort published UML 0.9. It gave software teams an early common notation for expressing structural and behavioral designs.

  12. 1997

    UML 1.0 adopted by OMG

    The Object Management Group adopts the Unified Modeling Language 1.0, standardizing notation for class, sequence, use case, and activity diagrams. UML gives software teams a shared vocabulary for structural and behavioral modeling that persists through subsequent revisions.

  13. 1997 Sep

    UML 1.1 adopted

    OMG adopted UML 1.1 as its first formal UML version. Standardized notation made diagrams more portable across modeling tools and organizations.

  15. 1998

    The Part-Time Parliament is published

    The published Paxos account made the protocol's safety argument and system model available as a citable primary description. It became a reference point for later multi-instance consensus systems.

  16. 1998 Aug

    JMS 1.0 defines a Java messaging API

    JMS 1.0 introduced a common Java API for messages, consumers, acknowledgement, and delivery modes. It made queue and publish-subscribe concepts portable across Java messaging providers.

  17. 1999

    Federal Enterprise Architecture Framework is published

    FEAF gave US federal agencies a common construct for architecture descriptions across business, data, applications, and technology.

  18. 1999

    PBFT demonstrates practical Byzantine replication

    Castro and Liskov presented Practical Byzantine Fault Tolerance for replicated state machines with arbitrary faulty replicas. The work made the fault model an explicit design choice rather than an assumed extension of crash tolerance.

2000s

58 milestones

  1. 2000

    Fielding defines REST in his dissertation

    REST described architectural constraints for networked hypermedia systems, giving HTTP API designers a vocabulary for resources, representations, and uniform-interface tradeoffs.

  3. 2000

    REST dissertation

    Roy Fielding’s dissertation documented REST as an architectural style, including the uniform interface, resources, representations, and stateless interaction. It gave HTTP API designers a vocabulary for resource-oriented contracts.

  4. 2000 May

    SOAP 1.1 published

    W3C published SOAP 1.1 as a Note for XML-based message exchange. Contract-first web services commonly paired these messages with explicit service descriptions.

  8. 2001

    Paxos Made Simple clarifies the core protocol

    Lamport's concise Paxos presentation centered promises, accepted values, and quorum intersection. It gave practitioners a direct path from a single chosen value toward repeated decisions.

  10. 2002

    CAP receives its formal proof

    Gilbert and Lynch formalized the consistency and availability tradeoff for atomic read-and-write objects during a network partition. It moved CAP from a design slogan toward precise failure-condition reasoning.

  15. 2003

    The Google File System documents fault-tolerant storage at scale

    GFS described a distributed file system built for large, unreliable clusters. Its design made failure handling and recovery first-class parts of an application storage system.

  16. 2003

    The Google File System documents large-scale cluster storage

    GFS described a distributed file system for data-intensive applications on commodity machines. Its design treated failure and aggregate performance as normal operating concerns.

  18. 2004

    AMQP work begins

    The AMQP effort started as an open protocol for business messaging. It put interoperability between messaging implementations on the agenda rather than leaving queue behavior entirely vendor-specific.

  19. 2004

    MapReduce narrows distributed batch programming

    MapReduce described a model that lets a runtime manage partitioning, scheduling, communication, and machine failures around map and reduce functions. It showed how a narrow interface can hide substantial distributed coordination.

  20. 2004

    MapReduce separates computation from runtime coordination

    MapReduce presented map and reduce functions while the runtime handled partitioning, scheduling, communication, and failure handling. The model made large parallel batch computation easier to express.

  21. 2004 Jul

    Jericho Forum presents de-perimeterisation at Black Hat

    The Jericho Forum argued that a hard trusted-inside boundary could not support open collaboration. Its presentation shifted protection toward data, systems, interoperable controls, and defense in depth.

  22. 2004 Aug

    Paxos Commit relates commit to consensus

    Gray and Lamport described Paxos Commit, using consensus on participant outcomes to tolerate coordinator failures. The work made replicated decision recording an explicit alternative to ordinary coordinator blocking.

  23. 2005 Jul

    UML 2.0 adopted

    OMG adopted UML 2.0. The major revision preserved UML as a formal option when a view needs defined modeling semantics rather than informal boxes and lines.

  24. 2005 Dec

    Event Sourcing documents event sequences as state history

    Martin Fowler describes storing application changes as an event sequence. That model later supports rebuilding query-focused state from published changes.

  25. 2006

    Amazon EC2 launches

    Amazon EC2 made compute capacity available on demand. Infrastructure design began to treat compute as an elastic service with explicit capacity and cost behavior.

  26. 2006

    Bigtable describes distributed structured storage

    Bigtable described a distributed storage system for structured data that partitions tables into tablets and manages them across a cluster. It made data placement and replication architecture central to application-scale storage.

  27. 2006

    Bigtable describes tablet-based structured storage

    Bigtable documented a distributed storage system for structured data across thousands of commodity servers. It connected data layout choices to workloads with different scale and latency needs.

  30. 2006 Mar

    Amazon S3 launches

    Amazon S3 made durable object storage available as an Internet service. Storage could become a separately selected architectural component rather than a resource provisioned with a server.

  31. 2006 Jun

    AMQP 0.8 is published

    AMQP 0.8 became the first published protocol version. It gave early brokers a shared wire-level target for queues, channels, and message transfer.

  32. 2006 Aug

    Amazon EC2 beta announced

    Amazon announced resizable compute capacity available through a web-service interface. It made acquiring and changing application capacity an API-driven operation rather than a server-procurement event.

  33. 2006 Aug 24

    Amazon EC2 beta announced

    Amazon introduced resizable compute capacity as a web service. It made obtaining and configuring compute capacity a cloud service concern rather than a data-center procurement task.

  34. 2006 Nov

    Mashery opens its API management service

    API documentation, community management, and access control became a managed service.

  35. 2007

    Dynamo exposes availability and consistency choices

    Dynamo described a highly available key-value store that sacrifices consistency in some failure scenarios. It made conflict handling and tunable replication part of an application's storage contract.

  36. 2007

    Dynamo publishes tunable replicated key-value storage

    Dynamo documented consistent-hash partitioning, replication, read and write thresholds, repair, and application-assisted conflict resolution. It supplied a practical vocabulary for availability-oriented replicated storage.

  37. 2007

    ISO/IEC 42010 adopts the architecture-description standard

    ISO/IEC 42010 carried the architecture-description concepts into an international standard. Teams could use a common framework for organizing views around concerns.

  38. 2007

    PlantUML first released

    PlantUML publishes its initial version, offering a text-to-UML rendering pipeline. It makes UML diagram generation accessible from plain text, establishing a pattern that later tools like Mermaid would follow with simpler syntax.

  39. 2007

    RabbitMQ started by Rabbit Technologies

    A joint venture of LShift and CohesiveFT began building an open-source message broker implementing AMQP 0-9-1, written in Erlang on the OTP framework. It established the exchange-queue-binding model the broker still uses.

  40. 2007 Feb

    RabbitMQ makes its first public release

    RabbitMQ's first public release provided an open-source AMQP implementation. It made an interoperable broker available to application teams rather than only to commercial middleware users.

  41. 2007 May

    Jericho Forum Commandments version 1.2 published

    The commandments documented design principles for systems operating beyond a fixed perimeter. They connected open networks with data protection, identity, trust, and policy enforcement.

  43. 2007 Jun

    WSDL 2.0 becomes a W3C Recommendation

    WSDL 2.0 standardized service descriptions with HTTP and SOAP support. It kept operations, messages, and bindings explicit and separate from service implementation.

  44. 2007 Dec

    Spring Integration is announced

    Spring announced an integration framework explicitly inspired by Enterprise Integration Patterns and aimed at message-driven application integration.

  45. 2008

    Google App Engine launches

    Google introduced App Engine as a managed application runtime. This established a platform-as-a-service option that shifts more runtime responsibility to the provider.

  46. 2008

    Lucidchart launches

    Lucidchart launches as a browser-based collaborative diagramming tool, making real-time co-authoring of diagrams accessible without desktop software. It demonstrates that the web can support professional-grade diagramming workflows.

  48. 2008 Apr

    Google App Engine introduced

    Google introduced App Engine as a managed application platform. It established a model in which application code could run without the team managing servers directly.

  49. 2008 Apr

    Google App Engine launched to early developers

    Google made a managed application platform available to early developers. Migration choices could now include moving an application to a managed runtime rather than only moving virtual machines.

  50. 2008 Jul

    Protocol Buffers open-sourced

    Google released Protocol Buffers, its schema language and binary message format, as open source. It later became the default interface definition language and message format that gRPC service definitions are written in.

  51. 2008 Sep

    RabbitMQ presented at Google Tech Talks

    Public exposure of the broker as an AMQP implementation, with client libraries planned for multiple languages. It positioned RabbitMQ as a general-purpose message-oriented middleware rather than a single-language library.

  52. 2008 Oct

    Microsoft announces Windows Azure

    Microsoft announced a platform combining hosted storage, compute, and networking services. The design scope explicitly included cloud, on-premises, and combined deployments.

  53. 2009

    Amazon Virtual Private Cloud launches

    Amazon introduced VPC to connect existing networks to isolated cloud resources through a VPN. Network and administrative boundaries became first-class cloud architecture decisions.

  54. 2009

    TOGAF 9 introduces the Content Metamodel

    TOGAF 9 added a formal Content Metamodel linking ADM artifacts, an architecture repository, and the Enterprise Continuum, moving the framework from guidance toward a structured method.

  57. 2009 Feb

    Spring Integration 1.0 GA is documented

    Spring described the 1.0 GA release and demonstrated channels, service activators, and adapters as a practical integration flow.

2010s

136 milestones

  1. 2010

    C4 diagram types receive their initial names

    The context, container, component, and class diagram types were named. The set gave software teams a compact hierarchy for explaining structure at different zoom levels.

  2. 2010

    Context, container, component, and class levels named

    The four diagram types were named in early 2010. Their sequence made progressive disclosure a repeatable way to control abstraction.

  3. 2010 Feb 1

    Windows Azure reached general availability

    Microsoft announced production availability of Windows Azure and SQL Azure in 21 countries. Public cloud became a production destination for application and database workloads across another major platform.

  4. 2010 Apr

    Acquired by SpringSource (VMware)

    Rabbit Technologies was acquired by SpringSource, a division of VMware, moving the project under commercial stewardship while keeping the source under the Mozilla Public License.

  5. 2010 Aug

    Forrester presents the Zero Trust model

    John Kindervag's webinar named a zero-trust model that treated all users as untrusted and placed security throughout the network rather than only at its edge.

  6. 2010 Aug

    RabbitMQ 2.0 changes its storage engine

    RabbitMQ 2.0 introduced a scalable storage engine and persistence API. Slow-consumer behavior and retained-message capacity became more explicit operational concerns for broker deployments.

  7. 2010 Nov

    CQRS Documents collects CQRS guidance

    Greg Young's CQRS Documents publishes guidance that connects command-query separation with event sourcing. It gives a shared vocabulary for separate write and read models.

  8. 2011

    C4 name introduced

    The C4 name was first used in early 2011. It gave the levels a compact vocabulary for discussing scoped software architecture views.

  10. 2011

    NATS released by Derek Collison

    Derek Collison released NATS, originally written in Ruby as the messaging control plane for Cloud Foundry. It established the subject-based publish-subscribe model the system still uses, optimized for a small footprint and low latency rather than persistence.

  11. 2011

    The C4 name is first used

    The C4 name made the four-level diagramming approach identifiable and teachable. It emphasized communicating a software system with a small, consistent set of views.

  14. 2011

    Twelve-Factor application methodology published

    The methodology collected portable-service practices such as external configuration, backing services, stateless processes, and build-release-run separation. Those practices remain design inputs for replaceable cloud workloads.

  15. 2011 May

    Architects discuss the microservice term

    A workshop of software architects used the term for a style they had been exploring. The discussion gave a name to independently deployable service-based systems.

  17. 2011 Aug

    Swagger 1.0 released

    The first Swagger Specification formalized a machine-readable description for HTTP APIs. That description could drive documentation and tooling from a contract rather than prose alone.

  18. 2011 Aug 10

    Swagger Specification 1.0 is released

    The first formal Swagger specification made an HTTP API description available as a machine-readable artifact for documentation and tooling.

  19. 2011 Sep

    NIST publishes SP 800-145

    NIST formalized cloud computing through essential characteristics, service models, and deployment models. The framework made responsibility boundaries and deployment choices easier to describe consistently.

  20. 2011 Oct

    AMQP 1.0 is published

    AMQP 1.0 was published after a protocol redesign from earlier AMQP versions. Practitioners had to distinguish AMQP 1.0 from the widely used AMQP 0.9.1 family rather than treating AMQP as one interchangeable wire protocol.

  22. 2011 Nov

    ISO/IEC/IEEE 42010 revises architecture description

    The joint revision superseded IEEE 1471 and ISO/IEC 42010:2007. It continued the stakeholder, concern, viewpoint, and view model for systems and software architecture.

  23. 2012

    NATS server rewritten in Go

    The server was rewritten in Go, which became the language the nats-server binary has shipped in since. The rewrite set the single-binary, high-throughput, low-latency properties the project is known for.

  24. 2012

    Raft separates consensus into teachable parts

    Raft organized consensus around leader election, log replication, and safety. Its decomposition made it easier to connect a replicated log with the state-machine model used by production coordination systems.

  25. 2012

    Spanner combines global replication with external consistency

    Spanner documented synchronously replicated data and externally consistent distributed transactions at global scale. It exposed clock uncertainty as part of the system design.

  26. 2012

    Spanner describes globally distributed transactions

    Spanner described synchronous replication and externally consistent transactions across geographic regions. It showed the operational cost of combining distributed consensus with a clock-uncertainty API.

  28. 2012 Mar

    Microservices case study is presented in Krakow

    James Lewis presented a case study connecting the style to Unix-like service composition. The example helped make the emerging approach concrete for practitioners.

  29. 2012 Apr

    Deployability and scalability talk frames decomposition

    Chris Richardson presented independently deployable services as an answer for applications where a monolith was not appropriate. The talk emphasized decomposition for deployability and scaling.

  30. 2012 Jun

    WSO2 releases API Manager alpha

    An open-source platform covered API creation, governance, security, and monitoring.

  31. 2012 Jun 28

    Google Compute Engine launched

    Google announced general-purpose virtual machines alongside its managed application platform. A migration could preserve a VM-oriented operating model when a managed runtime was not suitable.

  33. 2012 Oct

    Kafka graduates as an Apache project

    Kafka graduated from the Apache Incubator. The project then continued as an Apache top-level project.

  34. 2012 Oct

    Kafka graduates from the Apache Incubator

    Kafka graduated as an Apache top-level project. The project formalized an open ecosystem around partitioned, persistent event streams.

  35. 2013

    Docker enters public beta

    Docker made a packaged container workflow broadly available to developers. It helped establish the application artifact model later used by container orchestrators.

  36. 2013

    Raft presents a decomposed leader-based design

    Ongaro and Ousterhout introduced Raft with separate leader election, log replication, and safety components. Its explicit leader model made replicated-log behavior easier to inspect and teach.

  37. 2013 Mar

    Docker released its first public version

    Docker made a developer-facing workflow for packaging and distributing containerized applications widely available. Container images became a practical immutable-artifact format for many delivery pipelines.

  38. 2013 May

    Project moves to Pivotal Software

    RabbitMQ became part of Pivotal Software, the VMware-EMC spin-out, which reorganized the broker alongside Spring and other developer tools. The broker model and protocol surface stayed unchanged.

  40. 2014

    Google publishes the first BeyondCorp architecture paper

    Google described removing the privileged intranet and making access depend on users and devices. The paper supplied a production example of resource access without location-based trust.

  41. 2014

    Mermaid.js first published

    Knut Sveidqvist publishes Mermaid, a JavaScript library that generates diagrams from Markdown-like text syntax. Its integration into GitHub's Markdown renderer makes diagram-as-code practical in pull requests and documentation without any external tooling.

  43. 2014

    Raft presents an understandable replicated-log protocol

    Raft separated consensus into leader election, log replication, and safety. Its presentation made a practical replicated state machine easier to reason about and implement.

  44. 2014

    Raft receives the USENIX Best Paper Award

    The Raft paper received a Best Paper Award at the 2014 USENIX Annual Technical Conference. Its publication and accompanying materials widened access to a leader-based consensus design for systems builders.

  45. 2014 Mar

    Fowler and Lewis publish Microservices

    The article described common characteristics such as business-capability organization, decentralized data management, and infrastructure automation. It made the architectural tradeoffs broadly discussable.

  46. 2014 Mar

    Kafka 0.8.1 releases

    The 0.8.1 release continued the replicated-log generation and provided a stable base for production adoption of partition leaders and in-sync replicas.

  47. 2014 Mar

    Microservices article consolidates the architecture style

    James Lewis and Martin Fowler publish their microservices article in installments. It gives the service-oriented context in which cross-service data patterns become operational concerns.

  49. 2014 Jun

    Kubernetes is created

    Google engineers created Kubernetes. A portable control plane for containerized workloads became a practical architectural option for distributed application deployment.

  50. 2014 Jun

    Kubernetes source code released

    Kubernetes was released as an open-source container-management project. It brought scheduling, deployment, scaling, and workload management into a common platform vocabulary.

  51. 2014 Aug

    Distributed-objects warning is applied to microservices

    Martin Fowler distinguished service boundaries from pretending remote calls are local objects. The warning reinforced explicit treatment of network failure and remote behavior.

  52. 2014 Sep

    Swagger 2.0 released

    Swagger 2.0 expanded the formal API description. It made a portable contract a more practical input to code generation, validation, and reference documentation.

  53. 2014 Sep 8

    Swagger 2.0 is released

    Swagger 2.0 expanded the formal contract model before the specification moved into open governance.

  54. 2014 Oct

    MQTT 3.1.1 becomes an OASIS standard

    MQTT 3.1.1 standardized a lightweight client-server publish-subscribe transport. It gave constrained and IoT environments a common messaging protocol.

  56. 2015

    Apcera and Synadia shape the project's path

    Development and stewardship moved through Apcera, where Derek Collison was CEO, seeding the commercial path that would become Synadia. The project kept its Apache 2.0 license while a company formed around it.

  57. 2015

    C4 renames its fourth diagram type to code

    The fourth level changed from classes to code during 2015–2016. The change avoided implying that every codebase should be explained through class diagrams.

  58. 2015

    Class level begins its transition to code

    C4 began replacing the class-level label with code during 2015 and 2016. The change clarified that detailed implementation views are optional and technology-specific.

  59. 2015

    RabbitMQ adds lazy queues

    RabbitMQ 3.6 added lazy queues as an option for queues that can become long. The feature highlighted disk and memory behavior as a capacity decision, not a detail hidden by the queue abstraction.

  60. 2015 Feb

    gRPC announced as an open source HTTP/2 RPC framework

    Google introduced gRPC, a remote procedure call framework built on HTTP/2 with generated clients and servers for several languages. It generalized Stubby, the RPC system Google had used internally since about 2001.

  61. 2015 Mar

    LinkedIn documents Kafka at scale

    LinkedIn described tiered clusters and audit counts that checked delivery from producers through downstream consumers. The operational model made end-to-end completeness a concern beyond broker health.

  63. 2015 May

    HTTP/2 published as RFC 7540

    The IETF published HTTP/2, which supplies the multiplexed streams and binary framing gRPC uses as its transport. gRPC standardized on HTTP/2 rather than defining its own wire transport.

  64. 2015 Jun

    Kubernetes 1.0 is released

    Kubernetes 1.0 established a production container-orchestration platform with a stable API. It gave service fleets a common way to schedule and manage workloads.

  66. 2015 Jul

    Cloud Native Computing Foundation is announced

    The CNCF was announced to advance common technologies for container-packaged, dynamically scheduled, microservices-oriented applications. Architecture practice gained a neutral home for shared cloud native infrastructure.

  67. 2015 Jul

    Kubernetes 1.0 and CNCF formation

    Kubernetes reached 1.0 and was donated to the newly formed CNCF. The project gained a vendor-neutral foundation for shared cloud native infrastructure.

  68. 2015 Jul

    Kubernetes 1.0 released and donated to CNCF

    Kubernetes reached version 1.0 and was contributed to the newly formed Cloud Native Computing Foundation. The project then had a vendor-neutral home for shared governance and ecosystem work.

  69. 2015 Nov

    Kafka 0.9.0 releases

    Kafka 0.9.0 added Kafka Connect, creating a framework for reusable source and sink integrations instead of application-specific movement for every system.

  70. 2015 Dec

    RabbitMQ 3.6.0 released

    The release series that became the long-running production baseline, with improved clustering and a new rabbitmqctl. It was the version many teams first met in production.

  71. 2015 Dec

    Swagger 2.0 donated to the OpenAPI Initiative

    The Swagger 2.0 specification was donated to the OpenAPI Initiative. The description format then moved under vendor-neutral governance as OpenAPI.

  72. 2015 Dec 31

    Swagger 2.0 is donated to the OpenAPI Initiative

    The donation moved the description format into vendor-neutral stewardship, which matters when a platform contract outlives one implementation choice.

  73. 2016

    Apache Pulsar is committed to open source

    Pulsar was committed to open source. It expanded the set of distributed messaging and streaming implementations available to practitioners.

  74. 2016

    BeyondCorp design-to-deployment account published

    Google documented deployment experience with dynamic device trust tiers. Zero trust moved from a high-level perimeter critique toward an operated access model.

  75. 2016

    C4 history captures the terminology change

    The C4 history records the transition away from the class label. This reinforced the distinction between a component view and whatever code-level detail is useful for a particular system.

  76. 2016

    Envoy proxy created at Lyft

    Envoy, an L7 proxy designed for cloud-native applications, was created at Lyft and contributed to the CNCF. It became the data-plane building block most service meshes, including Istio, would build on.

  77. 2016

    Istio founded by Google, IBM, and Lyft

    Istio was founded by Google, IBM, and Lyft as a CNCF project, with Envoy as its data plane. It framed the data-plane and control-plane split that became the canonical mesh architecture.

  78. 2016

    Linkerd announced as the first service mesh

    Buoyant announced Linkerd, built on the Finagle RPC stack, as the first project to call itself a service mesh. It framed the category: an infrastructure layer for service-to-service communication.

  79. 2016

    NATS Streaming (STAN) adds persistence

    NATS Streaming, known as STAN, added a persistence layer on top of Core NATS for at-least-once delivery and replay. It was the first answer to "what if a message must survive time" before JetStream replaced it.

  80. 2016

    Protocol Buffers 3.0.0 introduces proto3

    Version 3 simplified the schema language, removed required fields, and added a canonical JSON mapping. proto3 became the recommended syntax for new gRPC service and message definitions.

  81. 2016 Mar

    CNCF accepted Kubernetes as its first hosted project

    CNCF accepted Kubernetes and transferred its intellectual property to the Foundation. This formalized a neutral governance path for a core cloud-native platform.

  82. 2016 Mar

    Kubernetes joins CNCF

    Kubernetes became the CNCF’s first hosted project. Its control-plane model moved from a single-provider origin into a vendor-neutral cloud native ecosystem.

  83. 2016 Mar 15

    AWS Database Migration Service became generally available

    AWS made its database migration service available to all customers. Replication and schema conversion became dedicated capabilities in migration planning rather than entirely custom work.

  84. 2016 May

    Kafka 0.10.0.0 releases

    Kafka 0.10.0.0 introduced Kafka Streams, making a Java client library part of the path for transformations, joins, and aggregations over topic data.

  85. 2016 May

    Prometheus joins CNCF

    Prometheus joined CNCF as an early monitoring project. Metrics became a prominent common component of cloud native operational practice.

  87. 2016 Aug

    gRPC 1.0 released

    gRPC 1.0 established a stable protocol and API surface for service contracts, including streaming call forms. API design work could therefore apply contract thinking beyond HTTP resource APIs.

  89. 2016 Sep

    Envoy is released as open source

    Envoy brought an edge and service proxy to cloud-native infrastructure.

  91. 2017

    Cadence open-sourced at Uber

    Uber released Cadence, an open-source engine for scalable, fault-tolerant, long-running workflows. It established the Workflow-and-Activity model and Event-History replay that Temporal later inherited.

  92. 2017 Mar

    gRPC joins the Cloud Native Computing Foundation

    Google donated gRPC to the CNCF as an incubating project and relicensed it under Apache 2.0. Stewardship moved from a single vendor to a foundation.

  93. 2017 May

    Istio 0.1 is announced

    Istio introduced a service-mesh approach for managing traffic, policy, and telemetry between services. This separated some cross-cutting network concerns from application code.

  94. 2017 Jun

    Kafka 0.11.0.0 adds idempotent and transactional producers

    Kafka 0.11 made idempotent and transactional producer modes available, which enabled atomic Kafka output and consumed-offset commits within a defined boundary.

  95. 2017 Jun

    Load balancing guidance published

    The project documented why a connection-level load balancer sends every call on one channel to the same backend, and set out L7, client-side, and lookaside balancing as the alternatives. This shaped how gRPC is deployed behind proxies and meshes.

  96. 2017 Jul

    OpenAPI 3.0 released

    OpenAPI 3.0 introduced a major revision of the HTTP API description format. Design reviews could use a standard artifact for paths, operations, schemas, responses, and security requirements.

  97. 2017 Jul 26

    OpenAPI Specification 3.0.0 is released

    OpenAPI 3.0 established the next major revision of the HTTP API description format used for contract review and tooling.

  98. 2017 Aug 14

    AWS Migration Hub announced

    AWS introduced a central view for tracking migrations across AWS and partner tools. Portfolio-level progress and issue visibility became a separate migration-management concern.

  100. 2017 Sep 25

    Azure Migrate announced

    Microsoft introduced discovery, assessment, dependency mapping, rightsizing, and compatibility reporting for Azure migrations. Discovery evidence became more directly connected to target planning.

  101. 2017 Nov

    Apache Kafka 1.0.0 ships

    Kafka 1.0.0 included improvements for exactly-once semantics. The release made transactional processing a documented part of the platform's delivery toolkit.

  102. 2017 Nov

    Certified Kubernetes program launched

    The conformance program established a common experience across Kubernetes offerings. It made portability and consistent upgrades a more explicit concern when selecting a managed platform.

  103. 2018

    C4 Model published by Simon Brown

    Simon Brown publishes the C4 model, a framework for software architecture diagrams organized as four zoom levels: context, container, component, and code. It provides the progressive-disclosure discipline that this course teaches as the primary approach to choosing view types.

  104. 2018

    C4 renames its fourth level from classes to code

    The C4 model changed its fourth diagram type from classes to code, reinforcing that code detail is optional.

  105. 2018

    Istio 1.0 released

    Istio 1.0 marked production-readiness for the sidecar-based mesh, with mTLS, traffic management, and telemetry. It began the period of large-scale enterprise adoption and the first wave of "should we adopt a mesh" decisions.

  106. 2018

    Linkerd 2.0 rewritten on Envoy

    Linkerd 2.0 was rewritten in Rust and Go on top of Envoy, moving to the same data-plane substrate as Istio while keeping a smaller control surface. It established the lightweight-mesh alternative that persists today.

  109. 2018 Feb

    RabbitMQ 3.7 with new config format and peer discovery

    3.7 introduced a layered configuration format and a peer-discovery subsystem for cluster formation, making reproducible cluster setup practical for the first time.

  110. 2018 Mar

    C4 uses code as its fourth diagram type

    A 2018 C4 presentation completed the switch to code as the fourth level. Teams could then describe the zoom sequence without implying that every implementation view is a class diagram.

  111. 2018 Mar

    Kubernetes became the first CNCF graduated project

    CNCF graduated Kubernetes after evaluating adoption, governance, and community criteria. The milestone marked maturation of a widely used container-orchestration foundation.

  112. 2018 Mar

    Kubernetes becomes the first graduated CNCF project

    CNCF graduated Kubernetes after its maturity review. Practitioners increasingly treated Kubernetes as a stable shared control-plane foundation.

  113. 2018 Mar

    Kubernetes graduates from CNCF

    Kubernetes became the first project to graduate from CNCF. Container orchestration had become an established option for managing distributed workload placement and lifecycle.

  114. 2018 Mar

    NATS accepted into the CNCF

    The Cloud Native Computing Foundation accepted NATS as a hosted project on 15 March 2018, giving the project a neutral stewardship home alongside Kubernetes and Prometheus. It confirmed the system as cloud-native infrastructure rather than a single-company product.

  116. 2018 Aug

    BPMN microservice orchestration describes sagas without two-phase commit

    Camunda documented orchestration of microservice transactions with compensation events. The example reflects the shift from shared resource managers toward durable workflow coordination.

  117. 2018 Aug

    Pulsar 2.1.0-incubating adds Pulsar IO and tiered storage

    The release added the connector framework and storage offload capabilities that widened the platform beyond brokered delivery.

  118. 2018 Sep

    Apache Pulsar becomes a top-level project

    Pulsar graduated as an Apache top-level project. Its governance milestone reflected the growth of a separate streaming ecosystem.

  119. 2018 Sep 24

    Azure migration services expanded

    Microsoft described Azure Migrate, Azure Database Migration Service, and Azure Data Box as migration capabilities. Different workload components could use specialized discovery, data, and transport services.

  120. 2018 Oct

    gRPC-Web becomes generally available

    A stable JavaScript client library let browser code call gRPC services through a translating proxy such as Envoy. It made gRPC reachable from the browser without a hand-written REST layer, within limits on client and bidirectional streaming.

  121. 2018 Nov

    Microservices Patterns publishes a pattern catalog

    Chris Richardson's book collects patterns for microservice transactions, querying, and communication. Saga, transactional outbox, and CQRS become a coherent implementation vocabulary.

  122. 2018 Nov

    Quorum queues announced as a data-safety direction

    Team RabbitMQ previewed quorum queues, a Raft-replicated queue type aimed at replacing classic mirrored queues with a safer, easier-to-operate replication model.

  123. 2019

    Service Mesh Interface and multi-mesh standardization

    The Service Mesh Interface (SMI) spec was launched to standardize a subset of mesh configuration across implementations, so that traffic policy could be portable between meshes. It formalized the idea that the mesh is pluggable.

  124. 2019

    Temporal founded as a fork of Cadence

    The original Cadence authors started Temporal Technologies and forked the project, carrying forward durable execution while re-architecting the platform and building a company around it.

  125. 2019 Feb

    Eventuate documents distributed data management patterns

    Eventuate documents saga and CQRS for cross-service data management, with transactional outbox for atomic state change and message publication. The guidance makes the pattern dependencies explicit in an implementation framework.

  126. 2019 May

    OpenTelemetry is introduced

    OpenCensus and OpenTracing announced their merger into OpenTelemetry. The project aimed to provide common APIs and tooling for distributed telemetry.

  127. 2019 May

    OpenTelemetry project is announced

    OpenTelemetry combined OpenCensus and OpenTracing work toward common telemetry APIs and data collection. It strengthened the practical expectation that requests can be traced across service boundaries.

  128. 2019 Aug

    Saga coordination guidance links outbox to message safety

    A microservices.io saga coordination article specifies transactional outbox as a way to publish a saga message in the same database transaction. The guidance focuses implementation attention on the commit-to-publish failure window.

  129. 2019 Sep

    AsyncAPI 2.0 released

    AsyncAPI 2.0 provided a specification for asynchronous APIs. Message channels, publishers, subscribers, and message schemas became first-class contract elements.

  130. 2019 Sep

    NIST releases the initial SP 800-207 draft

    The draft defined logical components, deployment models, use cases, and a migration roadmap in technology-neutral language. Public review began a shared architecture vocabulary beyond individual vendor or enterprise designs.

  132. 2019 Sep 11

    AsyncAPI 2.0.0 is released

    AsyncAPI 2.0 provided a machine-readable description format for asynchronous interfaces, extending contract-first practice beyond request-response APIs.

  133. 2019 Oct

    CloudEvents 1.0 reaches a stable specification

    CloudEvents 1.0 defined common event metadata and transport bindings. It improved portability of event descriptions across services and platforms.

  135. 2019 Nov

    RabbitMQ 3.8 ships quorum queues

    3.8 made quorum queues generally available and shifted the recommended path for durable, replicated workloads away from classic mirrored queues. The 3.8 series reached end of life in July 2022.

  136. 2019 Dec

    Pivotal re-acquired by VMware

    Pivotal was acquired back by VMware, returning RabbitMQ to VMware stewardship and eventually to Broadcom's Tanzu group, where the broker has remained commercially supported since.

2020s

62 milestones

  1. 2020

    JetStream replaces STAN

    JetStream replaced NATS Streaming as the built-in persistence layer, integrated into the nats-server binary rather than a separate process. It brought streams, consumers, at-least-once delivery, and replay under one server, removing the operational split STAN required.

  2. 2020

    Leaf nodes and super-clusters broaden the topology

    Leaf nodes and super-clusters gave NATS a topology that extended to the edge and spanned regions, making one logical messaging fabric cover cloud, edge, and bridged systems. It moved NATS from a cluster product to a connective tissue across environments.

  3. 2020

    Structurizr DSL released

    Structurizr publishes a domain-specific language for defining C4 model diagrams as code. It ties architecture documentation to a text source that can be versioned, reviewed, and rendered into the four C4 view types automatically.

  4. 2020 Feb

    First public Temporal Server releases

    Temporal published its early open-source server builds, beginning the public v0.x line that let teams run the Service themselves ahead of a stable release.

  5. 2020 May

    Kubernetes graduates from CNCF

    CNCF graduation marked Kubernetes as a mature project under the foundation's criteria. The ecosystem around running and operating service fleets had become a mainstream platform foundation.

  6. 2020 Aug

    Kubernetes Ingress reaches general availability

    Version 1.19 stabilized host and route configuration for incoming HTTP traffic.

  7. 2020 Aug

    NIST publishes SP 800-207

    The final publication established zero trust tenets, policy engine, policy administrator, policy enforcement point, trust-algorithm inputs, threats, and deployment approaches as a reference architecture.

  9. 2020 Sep 30

    Go SDK reaches 1.0.0

    The Go SDK reached a stable 1.0.0 alongside the server, giving the first production-supported way to write Workflows and Activities and run Workers against the platform.

  10. 2020 Sep 30

    Temporal Server 1.0.0 reaches general availability

    The 1.0.0 release marked the Temporal Server as production-ready, stabilizing the durable-execution runtime and its APIs for adopters.

  11. 2020 Dec

    gRPC-JS 1.0 released

    A pure-JavaScript implementation for Node.js reached 1.0 and replaced the C-based add-on as the recommended library, removing a native build step from Node deployments.

  12. 2020 Dec

    Kubernetes deprecates dockershim

    Kubernetes announced the future removal of its built-in Docker Engine adapter. Cluster operators had to identify runtime dependencies and move toward CRI-compatible runtimes.

  13. 2021

    Consul Connect and Kuma broaden the mesh field

    HashiCorp Consul Connect and the CNCF Kuma project broadened the mesh field beyond Istio and Linkerd, offering mesh capability integrated with service discovery and multi-platform deployment respectively.

  14. 2021

    Temporal Cloud enters the market

    Temporal introduced its hosted Service, letting teams run Workers against a managed Server and database instead of operating the four-service Server themselves.

  15. 2021 Feb

    OpenAPI 3.1 released

    OpenAPI 3.1 aligned its Schema Object with JSON Schema draft 2020-12 and added webhooks. HTTP API contracts could express schema constraints with closer alignment to the wider JSON Schema ecosystem.

  16. 2021 Feb 15

    OpenAPI Specification 3.1.0 is released

    OpenAPI 3.1 aligned its schema vocabulary more closely with JSON Schema, affecting how API contracts express instance constraints.

  17. 2021 May

    Executive Order 14028 directs federal zero trust adoption

    The order required federal civilian agencies to plan for zero trust architecture. The directive made implementation an accountable government program rather than only an architectural recommendation.

  19. 2021 Jul

    RabbitMQ Streams are introduced

    RabbitMQ introduced Streams as a persistent, replicated data structure with non-destructive consumption. The addition made replay-by-offset an explicit alternative to removal-oriented work queues.

  20. 2021 Jul

    Streams introduced

    A new append-only, replay-by-offset, replicated log model landed alongside classic and quorum queues, aimed at high-throughput fanout and replay use cases that pop queues handle poorly.

  21. 2021 Jul 13

    Migrate for Compute Engine V5 described as a managed service

    Google described replication-based VM migration with test clones, migration groups, and cutover. Testable replication and grouped execution became part of the service workflow.

  23. 2021 Sep

    Kafka 3.0 advances KRaft metadata management

    Kafka 3.0 introduced KRaft metadata and API improvements while the mode was still not recommended for production. Operators began planning for a controller model without ZooKeeper.

  24. 2021 Oct

    Proxyless gRPC service mesh with xDS

    gRPC libraries gained a built-in xDS client, so a control plane such as Istio could configure routing, load balancing, and mutual TLS for gRPC clients directly, without an Envoy sidecar next to every workload.

  25. 2022

    D2 scripting language released

    Terrastruct releases D2, a modern diagram scripting language with improved auto-layout and a focus on developer ergonomics. It advances the diagram-as-code category by treating layout as a first-class concern rather than an afterthought.

  26. 2022

    KV and object stores on JetStream

    JetStream's key-value store and object store arrived as higher-level abstractions on streams and consumers, letting applications use NATS as a replicated KV or chunked-object store without a separate system.

  27. 2022 Jan

    OMB issues the Federal Zero Trust Strategy

    Memorandum M-22-09 set goals across identity, devices, networks, applications and workloads, and data. Agencies received concrete outcomes for translating the architecture into programs and controls.

  28. 2022 Mar

    At-least-once dead lettering arrives for quorum queues

    RabbitMQ 3.10 added an opt-in at-least-once dead-letter strategy for quorum queues. It changed dead-letter transfer from a potentially lossy route into a retrying route when the target is temporarily unavailable.

  31. 2022 Apr

    TOGAF Standard, 10th Edition

    The 10th Edition split the standard into Fundamental Content and TOGAF Series Guides, separating enduring concepts from configurable practice and adding guidance for agile enterprises.

  32. 2022 May

    Envoy Gateway is introduced

    Envoy Gateway focused Envoy's ecosystem on north-south API gateway traffic.

  33. 2022 May

    Kubernetes 1.24 removes dockershim

    Kubernetes 1.24 removed dockershim from kubelet. Runtime integration became an explicit cluster design and migration concern.

  34. 2022 Jul

    Super streams for partitioned streaming

    Super streams partition a single logical stream across several stream instances for throughput beyond one node, with single-active-consumer support across partitions.

  35. 2022 Sep

    DoD Zero Trust Reference Architecture version 2.0 released

    The second reference architecture organized capabilities and activities for mission systems. It expanded the operational relationships around identity, devices, applications, data, networks, analytics, and automation.

  36. 2022 Sep

    Istio announces ambient mode

    Istio announced ambient mode, replacing per-pod sidecars with a node-level ztunnel for L4 mTLS and optional waypoint proxies for L7. It directly addressed the sidecar resource and operational cost that had slowed mesh adoption.

  37. 2022 Oct

    Kafka 3.3 marks KRaft ready for new clusters

    Kafka 3.3 marked KRaft production ready for new clusters. The guidance still distinguished new deployments from migration of existing ZooKeeper-based clusters.

  38. 2022 Oct

    KRaft becomes production ready for new clusters

    Kafka 3.3.1 documented KRaft mode as production ready for new clusters, making controller and broker role design a standard operational concern.

  39. 2022 Nov

    DoD Zero Trust Strategy and Roadmap released

    The strategy connected department-wide adoption, secured systems, technology acceleration, and enabling processes to a target implementation roadmap.

  40. 2023

    Excalidraw acquires tldraw

    Excalidraw, the freehand collaborative sketching tool, acquires tldraw. The merger consolidates the low-fidelity sketching category and validates freehand diagramming as a distinct phase in the diagramming workflow, complementary to formal diagram-as-code tools.

  41. 2023

    Istio graduates at the CNCF

    Istio graduated from the CNCF incubator, marking the project as mature and widely adopted. It confirmed the service mesh category as a standard part of the cloud-native stack rather than an experiment.

  42. 2023

    Mermaid enters GitHub Markdown natively

    GitHub adds native rendering support for Mermaid diagrams in Markdown files. Diagram-as-code diagrams in pull requests, issues, and documentation can now be rendered by the platform itself, removing the need for external rendering plugins.

  43. 2023 Feb

    Kafka 3.4 introduces early-access migration

    Kafka 3.4 added early-access migration from ZooKeeper to KRaft. The feature was intended for testing rather than production use at that point.

  44. 2023 Feb

    Kafka 3.4 supports ZooKeeper-to-KRaft migration

    Kafka 3.4 added the migration path from ZooKeeper mode to KRaft mode, turning the architectural transition into an upgrade-planning concern for existing clusters.

  45. 2023 Feb

    Modern research revisits two-phase commit overhead

    A research report quantified the network rounds and durable log writes on the two-phase commit critical path. It kept protocol overhead and fault behavior in active design discussion.

  47. 2023 Apr

    CISA publishes Zero Trust Maturity Model version 2.0

    The model defined traditional, initial, advanced, and optimal stages across five pillars and three cross-cutting capabilities. It gave operators a progression for automation, visibility, and integrated policy.

  48. 2023 Jun

    Protocol Buffers Editions announced

    Editions replace the fixed choice between proto2 and proto3 syntax with a per-file edition number and individually selectable features. It changes how the behavior of a gRPC schema evolves over time.

  49. 2023 Aug 4

    TypeScript SDK reaches 1.0.0

    The TypeScript SDK hit a stable 1.0.0, extending first-class, production-supported Workflow and Activity authoring to the JavaScript ecosystem alongside the existing SDKs.

  50. 2023 Sep

    NIST publishes SP 800-207A

    The publication adapted zero trust access control to cloud-native applications across multiple clouds. It added identity-tier and network-tier policies, service meshes, and gateways to the implementation vocabulary.

  51. 2023 Dec 5

    AsyncAPI 3.0.0 is released

    AsyncAPI 3.0 updated the event API description model, keeping message-driven interfaces in the same contract-first design conversation as HTTP APIs.

  52. 2024

    eBPF and sidecarless dataplanes go mainstream

    Cilium and eBPF-based dataplanes became a mainstream mesh alternative, moving L4 identity and policy into the kernel and skipping the userspace proxy entirely. It opened the question of whether a mesh needs a proxy at all.

  53. 2024

    NATS positioned for agentic AI workloads

    NATS was positioned for agentic AI — agent-to-agent communication with automatic service discovery and multi-region GPU inference routing. It reframed the subject-based model as a fit for LLM tool calls and event streams, work the original 2011 system was not designed for.

  55. 2024 Aug

    RabbitMQ 4.0 with native AMQP 1.0

    4.0 made AMQP 1.0 a first-class protocol rather than a plugin, reworked quorum queue features, and began the transition toward Khepri as the metadata store, retiring legacy assumptions from the 3.x line.

  56. 2024 Sep

    Workflow Update enabled by default

    With the v1.25.0 server line, Workflow Update — a message that sends input, runs handler logic, and returns a result — no longer required manual enabling, making synchronous request-response a standard way to interact with a running Workflow.

  57. 2025

    Gateway API becomes the default north-south entry

    The Kubernetes Gateway API became the default way to configure ingress and mesh-adjacent gateways across implementations, standardizing the edge configuration this course separates from the east-west mesh.

  59. 2025 Apr

    CNCF reaffirms NATS stewardship

    The CNCF published a commitment to protecting NATS and the integrity of the open-source project, addressing governance concerns as the Synadia commercial relationship evolved. It reaffirmed the project's neutral stewardship home.

  60. 2025 Sep

    Khepri default metadata store roadmap

    Team RabbitMQ published the roadmap for making Khepri, a Raft-based metadata store, the default in place of Mnesia, removing a long-standing cluster-recovery hazard.

  61. 2026

    Ambient mode reaches general availability in Istio

    Istio's ambient mode reached general availability, making the sidecarless data plane the recommended path for new deployments and the sidecar the legacy option for complex L7 needs.

  62. 2026

    NATS 2.14 and MQTT/WebSocket on one process

    The 2.14 release carried clustering, JetStream, leaf nodes, MQTT, and WebSocket as configuration on the same single nats-server binary, consolidating the protocol surface the project had accumulated into one process.