software architecture

Complexity is the Gotcha of Event-driven Architecture

How Architecture & Culture Go Hand in Hand

Adaptive Architectures: Reimagining API Federation & Microservices Integration

Thinking about your Systems with Bytesize Architecture Sessions

Understanding Distributed Architectures - The Patterns Approach

Architecture Modernization

Serverless: the Future of Software Architecture

Bringing EDA to the Containers World

Outsmarting the Genie: How to Make Smart Architecture Decisions when Building Gen AI Apps

50.000 Orange Stickies Later

How to Build CQRS and Event Sourcing Application with Axon and Pivotal Cloud Foundry

The Big Friendly Monolith

Location Transparency

Pragmatic Event-Driven Microservices

REST beyond the Obvious - API Design for ever Evolving Systems

Systems Architecture at Massive Scale: The Unreasonable Effectiveness of Simplicity

Dynamic Non-Events

Adaptive Architectures - Building API Layers that Build Themselves

Panel Discussion

C4 Models as Code

Enabling Microservice Success

Adaptive Architectures - Building API Layers that Build Themselves

Adaptive Socio-Technical Systems with Architecture for Flow

Event Design & Event-first Development

Minimum Viable Migrations (MVMs): A Path to Cloud Native EDAs

The Road To Event-Driven Architecture At LEGO.com

Event-driven Architectures in Practice: Lessons Learned Building an e-Commerce platform in Six Months at Cinch

Best Practices to Design & Build Event-driven Applications

How to Choose the Right Messaging Service for Your Workload

Advanced Event-driven Architectures at the LEGO Group

Adaptive Architectures - Building API Layers that Build Themselves

Adaptive Socio-Technical Systems with Architecture for Flow

Adaptive Socio-Technical Systems with Architecture for Flow

Trust Deterministic Execution to Scale and Simplify Your Systems

Making Kafka Queryable with Apache Pinot

Trust Deterministic Execution to Scale and Simplify Your Systems

Crafting Robust Architectures for a Resilient Future

Software Architectures, Team Topologies and Complexity Science

Trust Deterministic Execution to Scale and Simplify Your Systems

Energy-Efficient Software Architecture for Developers

Choose Your Own Adventure: The Treacherous Trek to Development

Making Software and Data Architectures More Sustainable

Minimal Viable Architecture

Minimal Viable Architecture

Minimal Viable Architecture

Building Evolutionary Architectures: Principles & Practices

Building Evolutionary Architectures: Principles & Practices

Building Evolutionary Architectures: Principles & Practices

Reactive Systems

Reflections on Re-architecting 2-tier to 3-tier

50.000 Orange Stickies Later

Uncoupling

Old Is the New New

Insecure Transit - Microservice

Keynote: The Many Meanings of Event-Driven Architecture

Microservices from the Trenches. Concepts, Design, Architecture, Code, Testing

Unconditional Code

Shopify's Architecture to handle 80K RPS Celebrity Sales

Lunar Ways Journey towards Cloud Native Utopia

Let’s Get Lazy: Exploring the Real Power of Streams

Serverless: Five Key Things you need to Know

Microservice API Management, Discovery Documentation and all that Jazz

Where Does the Real World End - The Blurring of the Physical and Digital

A Microservices Journey

How to Become a Great Software Architect

Let's all just agree: Achieving consensus in Blockchain-based systems

Making Microservices Micro with Istio and Kubernetes

Modular Monoliths

Using Graph Theory and Network Science to Explore your Microservices Architecture

CERN, from an IT Perspective

Serverless Beyond the Hype

Event-based Architecture and Implementations with Kafka and Atom

Serverless Architectural Patterns and Best Practices

Visualizing Cloud Systems

“Good Enough” Architecture

The 7 Quests of Resilient Software Design

Event-Driven Microservices - not (just) about Events!

The Hidden Costs of Poor Database Access

Clean Architecture with ASP.NET Core 3.0

Modern Continuous Delivery

Taking Machine Learning Research to Production: Solving Real Problems

Modern Continuous Delivery

SaaS Deep Dive: Designing and Building Multi-Tenant Solutions

Why Are Distributed Systems so Hard?

Robot DJs: Better Spotify Playlists through Music Theory and Discrete Optimization

Welcome to Serverless 2.0

A Case For Outside-In Design
!["Good Enough" Architecture [VIRTUAL]](https://img.youtube.com/vi/PzEox3szeRc/maxresdefault.jpg)
"Good Enough" Architecture [VIRTUAL]

Modern Continuous Delivery

Building a Blockchain in Erlang

All The World’s A Staging Server

Practical End-to-End Container Security at Scale

Don’t Get Blamed for Your Choices

Visualizing Cloud Systems

Battle of the Circuit Breakers: Resilience4J vs Istio

Ray: A System for Distributed Applications

Shortening the Architectural Feedback Loop

Stop Punching Yourself in the Face

“Good Enough” Architecture part 2

“Good Enough” Architecture part 1

Five Things Every Developer Should Know about Software Architecture

Kafka as a Platform: The Ecosystem from the Ground Up

#FAIL

Diagrams as Code 2.0

A Developer's Introduction to Developing in Web3

Democratising Software Architecture

Digital Cash: What It Is and How It Works

Practical (a.k.a. Actually Useful) Architecture

Generic or Specific? Making Sensible Software Design Decisions
![Calling Functions Across Languages [Live Streamed]](https://files.gotocon.com/uploads/images/conference_66/sessions/2576/original/richardCHI23.jpg)
Calling Functions Across Languages [Live Streamed]

REPLs All The Way Up: A Rubric For Better Feedback Loops

Industry Myth Busting

The Art of Embracing Failures with Serverless Architectures

Master Software Architecture

Navigating Complexity with Systems Thinking

Software Architecture for Tomorrow: Expert Talk

How to Deal with Software Complexity

Live interview

There's No Such Thing As Plain Text

The C4 Model – Misconceptions, Misuses & Mistakes

There's No Such Thing As Plain Text

Facilitating Software Architecture

Infrastructure as Code

There's No Such Thing As Plain Text

Bottom-up Architecture – Bridging the Architecture Code Gap

Architecture Modernization: Aligning Software, Strategy & Structure

Design & Develop Distributed Software Better with Multiplayer

Building Modern Software at Scale: Architectural Principles Two Decades in the Making

Balancing Coupling in Software Design

"Residues" & "The Architect’s Paradox"

The World after Microservice Migration with Service Mesh and Contract Testing

You Keep Using That Word

Creating Software with Modern Diagramming Techniques

Thinking about your Systems with Bytesize Architecture Sessions

Breaking the Architecture Bottleneck

Why Software Architecture is Mostly Communication

State of the Art of AI Tools in Micro-Frontend Architectures

Thinking about your Systems with Bytesize Architecture Sessions

Understanding Distributed Architectures - The Patterns Approach

C4 Models as Code

Creating Software with Modern Diagramming Techniques

Infrastructure as Code

Catching Commits to Secure Infrastructure as Code

Serverless Compute at the Heart of Your EDA

Innovations in Serverless & Event-Driven Solutions

Confusion in the Land of the Serverless

Packaging Applications in a Serverless World!

DynamoDB in an EDA World

The Art of Embracing Failures with Serverless Architectures

The Value Flywheel Effect: A Modern Cloud Strategy

Optimizing Amazon EventBridge Pipes with Apache Kafka at ProSiebenSat.1

Startup Talk: How to Seamlessly Plug Into AWS's Open Ecosystem as a 3rd Party Tool

Serverless Beyond the Hype

Serverless Development on AWS

Alexa, Let’s Build a Serverless Skill

Optimizing Kubernetes Deployments with Helm

Accelerating Event-driven Architecture with Domain-driven Design

Serverless Architectural Patterns and Best Practices

Complexity is the Gotcha of Event-driven Architecture

Are We Post-Serverless?

From Your Keyboard to your Customers without a Server to Manage In-between

Bringing EDA to the Containers World

Scaling for Global Growth with Modern Cloud

How Beauteous Technology is! O Brave New World

Serverless Apps on Cloudflare

Building Low-Code Applications with Serverless Workflows

What Does THIS Button Do? Serverless and IoT

Microservices Without Servers

A Year of Diagnosing Pediatric Cancer with Event Driven Architecture

Developing Highly Scalable Image Storage Solution with AWS Serverless

Breaking Language Barriers with AI

Patterns for Building Event-driven Web & Mobile App Backends

Web3 Beyond Blockchains

Serverless Chatbots with Amazon Lex & AWS Lambda

How Event Driven Architectures Go Wrong & How to Fix Them

Outsmarting the Genie: How to Make Smart Architecture Decisions when Building Gen AI Apps

Serverless is the Abstraction We Deserve

Robot DJs: Better Spotify Playlists through Music Theory and Discrete Optimization

Serverless: Five Key Things you need to Know

Building Evolutionary Infrastructure

Building Practical, Cost-Efficient GenAI Solutions Using Serverless

Serverless + Modern Agile: A Match made in Silicon Heaven

Serverless: the Future of Software Architecture

Welcome to Serverless 2.0

The Future of Event-Driven Architectures: What Opportunities Lie Ahead

Static Code Analysis - A Behind-the-scenes Look

Crossing the River by Feeling the Stones

Event-Driven Integration Today and Tomorrow

Complexity is the Gotcha of Event-driven Architecture

Thinking Serverless: From User Request to Serverless Solution

A Tour of the Modern Java Platform

What Does THIS Button Do? Serverless and IoT

Containerization ≠ Modernization: Kick-Start Your True Transformation Journey

Azure Serverless for Developers

Serverless 2.0: Get started with the PLONK Stack

Unlocking Faster and Efficient Data Processing with Serverless

Journey to EDA: Patterns, Best Practices, and Practical Tips

Serverless Compute at the Heart of Your EDA

Building a "Backend-less" URL Shortener

Embracing Complexity in Serverless!

Thinking Asynchronously

Creating Momentum with The Value Flywheel Effect

Building a Serverless Distributed Ledger with FaunaDB

How Serverless Technologies Accelerate Our Digital Transformation

Designing for the Serverless Age

Scaling EDA Workloads with Kubernetes, KEDA & Karpenter

Use Solace and AWS to Create a Global EDA Backbone

Harnessing EDA & Workflows to Build Real-world Generative AI Applications

Shifting Gears: From Events to Event Driven

The Future of Serverless

Why the Fuss about Serverless

Serverless Compute at the Heart of Your EDA

Optimizing EDA Workflows: Realtime Serverless Communication with Momento Topics

Evolving Serverless Architectures

Empowering Architectural Evolution: Governing Event-Driven Solutions with Confidence

Developing Highly Scalable Image Storage Solution with AWS Serverless at ip.labs

When should you use a Serverless Approach?

Cloud Trends

Panel Discussion

Adopting Cloud Native EDAs - The Serverless Staircase

Using Serverless and ARM64 for Real-Time Observability

Serverless: Five Key Things you need to Know

The API is the Platform

Scaling Kubernetes-based Event-driven Workloads with Keda and Karpenter

Serverless and Event-driven Patterns for GenAI

Scaling for Global Growth with Modern Cloud

Serverless Tales from the Trenches

Observability in an Asynchronous World

Evolving Your Containerized REST Based Microservices to Adapt to EDA

Serverless Compute at the Heart of Your EDA

Going Serverless with VueJS

The World after Microservice Migration with Service Mesh and Contract Testing

Making Microservices Micro with Istio and Kubernetes

AMA with Matt Turner

The Future is Istio

Unconditional Code

Patterns for Building Event-driven Web & Mobile App Backends

Patterns of Distributed Systems

Building Next-Generation Applications with EDA

Patterns of Effective Teams

Patterns for Building Event-driven Web & Mobile App Backends

RESTful API Patterns and Practices

REST beyond the Obvious - API Design for ever Evolving Systems

Cloud Native Java

Evolving Your Containerized REST Based Microservices to Adapt to EDA

Discovering RESTful Web Microservices: A Traveler's Guide

You Keep Using That Word

Software Architecture for Tomorrow: Expert Talk

Event-Driven Microservices - not (just) about Events!

Principles for Developing More Secure Systems

Distributed Data Stores on Kubernetes

Analyzing Pwned Passwords with Apache Spark

Building a Serverless Distributed Ledger with FaunaDB

GameDays: Practice Thoughtful Chaos Engineering

Observability, Distributed Tracing & the Complex World

Site Reliability Engineering at Google

The Soul of Erlang and Elixir

Secure Substrate: Building the Moby Whale

Adopting gRPC: Overcoming Team and Technical Hurdles

Jepsen 9: A Fsyncing Feeling

Data-Driven Engineering

Build Abstractions Not Illusions

Reactive Systems

Build Abstractions Not Illusions

Practicalities of Productionizing Distributed Systems, 2018

Design & Develop Distributed Software Better with Multiplayer

Building Distributed Systems with Kubernetes

Patterns of Distributed Systems

Designing Features for Mature Systems: Lessons Learned from Manta

Build Abstractions Not Illusions

You Keep Using That Word

The Soul of Erlang and Elixir

The Art of Embracing Failures with Serverless Architectures

Building a Blockchain in Erlang

Taking Machine Learning Research to Production: Solving Real Problems

How to Build CQRS and Event Sourcing Application with Axon and Pivotal Cloud Foundry

Temporal Modelling

Pragmatic Event-Driven Microservices

Location Transparency

The Big Friendly Monolith

Not Just Events: Developing Asynchronous Microservices

Building Modern Software at Scale: Architectural Principles Two Decades in the Making

Enabling Microservice Success

The Big Friendly Monolith

Modular Monoliths

Balancing Coupling in Software Design

Serverless is the Abstraction We Deserve

Considering Migrating a Monolith to Microservices? A Dark Energy, Dark Matter Perspective

Optimizing Organizational Flow with Wardley Mapping & DDD

Master Software Architecture

When Customers Don't Share A Language

Domain-Driven Refactoring

Practical Tips and Tricks for CI/CD Success

Security in the Delivery Pipeline

Kubernetes in Real Life

Batching vs. Streaming - John Deere's Journey to Scale & Process Millions of Measurements a Second

Observability for Data Pipelines: Monitoring, Alerting, and Tracing Lineage

Beyond Microservices: Streams, State and Scalability

Collaborative Software Design

Balancing Coupling in Software Design

The 7 Quests of Resilient Software Design

"Residues" & "The Architect’s Paradox"

Simplicity As A Superpower: Navigating The Complexity Maze In Software Development

Knee Deep in Microservices

IoT & MicroServices in the Home - Technical Marriage Made in Heaven

Software Mistakes & Tradeoffs

Security and Trust in a Microservices World

Breaking Things on Purpose

Developing a Chaos Architecture Mindset

Not Just Events: Developing Asynchronous Microservices

Cloud Native is about Culture, not Containers

The Seven (More) Deadly Sins of Microservices

Learning to Love your Non-functionals

How to Build CQRS and Event Sourcing Application with Axon and Pivotal Cloud Foundry

Adopting gRPC: Overcoming Team and Technical Hurdles

Insecure Transit - Microservice

Microservices Without Servers

Resilience Engineering in a Microservice Landscape

Microservices from the Trenches. Concepts, Design, Architecture, Code, Testing

In the Eventual Consistency of Succeeding at Microservices

The Big Friendly Monolith

The Journey to Microservices from a Startup Perspective

One Journey, many Paths: A Pragmatic Guide for Migrating to Microservices

Why BFF (Backend for Frontend) Is Key to Your Microservices Journey: A Morningstar Case Study

Why the Fuss about Serverless

Pragmatic Microservices for Organisational Scalability

Lunar Ways Journey towards Cloud Native Utopia

Securing APIs and Microservices with OAuth and OpenID Connect

Supersonic, Subatomic Eclipse MicroProfile

With Age Comes Wisdom (Hopefully): Lessons Learned in 15 Years of Building Software

Reactive Systems

Temporal Modelling

Processing Streaming Data with KSQL

Bootstrapping Microservices

A Microservices Journey

Building Next-Generation Applications with EDA

Making Microservices Micro with Istio and Kubernetes

Modular Monoliths

Using Graph Theory and Network Science to Explore your Microservices Architecture

The World after Microservice Migration with Service Mesh and Contract Testing

Troubleshooting & Debugging Microservices in Kubernetes

Observability, Distributed Tracing & the Complex World

GameDays: Practice Thoughtful Chaos Engineering

Introduction to Micronaut: Lightweight Microservices with Ahead of Time Compilation
![Why Your Private Cloud is Probably a Bad Idea [VIRTUAL]](https://img.youtube.com/vi/MbaPtzSuQII/maxresdefault.jpg)
Why Your Private Cloud is Probably a Bad Idea [VIRTUAL]

Discovering RESTful Web Microservices: A Traveler's Guide

Adaptive Architectures - Building API Layers that Build Themselves

Event-Driven Microservices - not (just) about Events!

3 Common Pitfalls in Microservice Integration and How to Avoid Them

Journeys To Cloud Native Architecture: Sun, Sea And Emergencies

Reactive Spring

Enabling Microservice Success

Journeys To Cloud Native Architecture: Sun, Sea And Emergencies

Modern Continuous Delivery

Role of Application Integration in Cloud Native and Microservices Landscape

Troubleshooting & Debugging Microservices in Kubernetes

Serverless is the Abstraction We Deserve

Adaptive Architectures - Building API Layers that Build Themselves

Discovering RESTful Web Microservices: A Traveler's Guide

A Case For Outside-In Design

Adaptive Architectures - Building API Layers that Build Themselves

Why GraphQL Between Microservices Is the Worst Idea and the Best Idea at the Same Time

Beyond Microservices: Streams, State and Scalability

High Velocity Development of Microservices

The Database Unbundled: Commit Logs in an Age of Microservices

Using Semantic Metadata to create an Automated Microservice Data Mesh

Battle of the Circuit Breakers: Resilience4J vs Istio

Microservices Out In the Wild

Cloud Chaos and Microservices Mayhem

Cloud Chaos and Microservices Mayhem

Thinking Asynchronously: Application Integration Patterns for Microservices

Rethinking Microservices with Stateful Streams

Microservices on Unison Cloud: Statically Typed, Dynamically Deployed

Software Architecture for Tomorrow: Expert Talk

Adaptive Architectures: Reimagining API Federation & Microservices Integration

There's No Such Thing As Plain Text

Contract-Driven Development - Turn your API Specification into Executable Contracts

There's No Such Thing As Plain Text

Considering Migrating a Monolith to Microservices? A Dark Energy, Dark Matter Perspective

Contract-Driven Development - Turn your API Specification into Executable Contracts

There's No Such Thing As Plain Text

Contract-Driven Development - Turn your API Specification into Executable Contracts

Architecture Modernization: Aligning Software, Strategy & Structure

Building Modern Software at Scale: Architectural Principles Two Decades in the Making

Balancing Coupling in Software Design

Clean Code: A Path to Better Programming

Microservices: Up and Running

Software Architecture for Software Developers

Why Architectural Work Comes Before Coding

GOTO Book Club Yule Special

Getting Started with Service Mesh

Unlock the Secrets of Great, Lasting APIs


Is Software Architecture Still Important?

Patterns of Distributed Systems

The Best of GOTO Book Club Part One

Software Mistakes and Tradeoffs

Architecting for Scale

Moving Beyond Monoliths and Microservices

Kubeflow for Machine Learning

Restful Web API Patterns & Practices Cookbook

Software Engineering at Google


Holiday Special 2022

Software Architecture: The Hard Parts

Code Complete: A Practical Handbook of Software Construction

Become an Effective Software Engineering Manager

Building Evolutionary Architectures

Anniversary Edition of The Pragmatic Programmer


The Art of Unit Testing

The Best of GOTO Book Club Part Two

Architecture Modernization

Enabling Microservices Success


Master Software Architecture

Building Multi-Tenant SaaS Architectures

Looks Good to Me- Constructive code reviews

Learning Microsoft Azure

Effective Platform Engineering

Collaborative Software Design


Communication Patterns: A Guide for Developers and Architects

Sooner Safer Happier: Antipatterns and Patterns for Business Agility

Balancing Coupling in Software Design

"Residues" & "The Architect’s Paradox"

Why Architectural Work Comes Before Coding

Is Software Architecture Still Important?

Software Architecture for Software Developers

Software Architecture for Software Developers

Is Software Architecture Still Important?

Why Architectural Work Comes Before Coding


Infrastructure as Code

How to Avoid Failure in Your Agile Retrospective

Retrospectives Antipatterns with Aino Vonge Corry

Serverless Apps on Cloudflare

AWS Cookbook: Recipes for Success on AWS


The Best of GOTO Book Club Part Two


Getting Started with Service Mesh

Restful Web API Patterns & Practices Cookbook

Patterns of Distributed Systems

Bootstrapping Microservices


Getting Started with Service Mesh


Bootstrapping Microservices

Domain-Driven Refactoring


Building Evolutionary Architectures

Balancing Coupling in Software Design

Kafka in Action

Design for Developers

Collaborative Software Design

Building Evolutionary Architectures

Microservices: Up and Running

Getting Started with Service Mesh


Bootstrapping Microservices


Enabling Microservices Success

The Best of GOTO Book Club Part One


Architecting for Scale

Moving Beyond Monoliths and Microservices

Building Micro-Frontends

Software Architecture: The Hard Parts


Learning Test-Driven Development

Software Engineering at Google

97 Things Every Cloud Engineer Should Know

Patterns of Distributed Systems

Crafting Robust Architectures for a Resilient Future

The Art of EDA Visuals: Exploring Concepts Through Graphics

How Architecture and Culture Go Hand in Hand

Expert Talk: DevOps & Software Architecture

Expert Talk: Continuous Architecture

Expert Talk: Software Security

Modern Software Practices in a Legacy System

Expert Talk: The Current State of Software Engineering

Expert Talk: Cloud Native and Serverless

The Current State of Cyber Security

Why Cloud Native is the New Standard

Expert Talk: Five Lines of Code

Five Things Every Developer Should Know about Software Architecture

1 Million Subscribers to the GOTO YouTube Channel 🎉

Software Architecture for Tomorrow: Expert Talk

How to Deal with Software Complexity

How to Continuously Deliver Quality Software Against All Odds

Revolutionizing Software with Moldable Development

Breaking the Architecture Bottleneck

Expert Talk: gRPC, Kubernetes & .NET

The Impact of Legacy Systems on Digital Transformations

Adoption and Future Perspectives for the Cloud

The Art of EDA Visuals: Exploring Concepts Through Graphics

Expert Talk: Cloud Native and Serverless

Innovations in Serverless and Event-Driven Solutions

Why Cloud Native is the New Standard

Building Modern Apps with Serverless & Feature Flags

Expert Talk: Are We Post-Serverless?

Expert Talk: gRPC, Kubernetes & .NET

How to Keep Your Cloud-Native Apps Secure

What are Micro-Frontends and How to Use Them

Design & Develop Distributed Software Better with Multiplayer

Beyond the Cloud: The Local-First Software Revolution

The Art of EDA Visuals: Exploring Concepts Through Graphics

Expert Talk: Software Security

Modern Software Practices in a Legacy System

Expert Talk: DevOps & Software Architecture

What are Micro-Frontends and How to Use Them

Expert Talk: Cloud Chaos & How Contract Tests Can Help

Expert Talk: Zig Programming Language and Linters

Expert Talk: What is Agile Sabotage?

Expert Talk: Cloud Native and Serverless

Thomas Vitale
Systematic
Software Architect, author of "Cloud Native Spring in Action", CNCF Ambassador, Oracle ACE Pro

Unmesh Joshi
ThoughtWorks
Principal Consultant at Thoughtworks & Author of "Patterns of Distributed Systems"

Ashley Peacock
Staff Software Engineer & Author of "Creating Software with Modern Diagramming Techniques"

Eduardo da Silva
Independent Consultant on Sociotechnical Systems, Architecture, and Leadership modernization

Ashley Peacock
Staff Software Engineer & Author of "Creating Software with Modern Diagramming Techniques"

Jones Zachariah Noel N
New Relic
AWS Serverless Hero / Senior Developer Relations Engineer at New Relic

Vishal Kumar Bhagchandani
Illinois Institute of Techn...
GDSC Lead @ Illinois Institute of Technology

Daniele Frasca
Seven.One Studios
Team Lead of Content Discovery and AWS Serverless Community Builder

Josh Kahn
Amazon Web Services
Worldwide Tech Leader for Serverless and a Principal Solutions Architect at AWS

Marcin Sodkiewicz
Ryanair
Principal Software Engineer @ Ryanair, AWS Community Builder & Leader, Cloud & Serverless technologies enthusiast

Brooklyn Zelenka
Ink & Switch
Author of numerous libraries including Witchcraft, and founded the Vancouver Functional Programming Meetup.

Jim Webber
Neo4j
Working on a variety of database research topics with a focus on fault-tolerance at Neo4j

Unmesh Joshi
ThoughtWorks
Principal Consultant at Thoughtworks & Author of "Patterns of Distributed Systems"

Madhu Sivasubramanian
ING
Domain Architect at ING with hands-on experience in distributed large-scale web applications

Chris Richardson
Microservices.io
Creator of the original CloudFoundry.com and author of 'POJOs in Action' and 'Microservices patterns'

Sam Newman
Independent
The Microservices Expert. Author of "Building Microservices" & "Monolith to Microservices"
Browse all tags
Here