@zhou7yuan

A personal story (change API URL) [0:13]
How does this happen? [0:38]

Great Architecture [1:10]
Not So Great Architecture [1:55]
Design Microservice Architectures the Right Way [2:29]
About Me [2:45]

Let's Start With a few Misconceptions [3:37]
M#1 teams to choose language [3:40]
  (expensive)
M#2 code generation is evil [4:32]
  (just a tech)
M#3 event log must be the source of truth [4:55]
  (ok to record service own record)
M#4 <= 3 services/developer [5:48]
  (automation)

Flow Platform Architecture [6:36]
API Definition [7:15]
Resource Oriented [8:33]
Definition in Git, with Continuous Integration [8:59]
Tests Enforce Consistency [9:36]
Tests Prevent Errors [10:20]
API Implementation Supported by Code Generation [11:50]
Code Generation: Routes [12:58]
Code Generation: Client [14:09]
Code Generation: Mock Client [15:30]
Now Let's Implement [16:41]

Database Architecture [17:25]
  Each micro service application owns its database
  No other service is allowed to connect to the database
  Other services use only the service interface (API+Events)
Create a Database [18:24]
Define storage requirements in metadata [19:29]
Code generation: Create a Table [20:16]
Code generation: Scala Class [21:56]
Automated Tests [22:55]
Test Resource Operations [23:16]

Time to Deploy [24:16]
Continuous Delivery [24:23]
Continuous Delivery (git) [25:01]
Continuous Delivery is Critical [25:50]
Auto Deploy on New Commit on Master [26:37]
Microservice Infrastructure - keep it simple [27:05]
Standard Health Checks [27:45]

Events [28:45]
Principles of an Event Interface [29:34]
  First class schema for all events
  Producers guarantee at least once delivery
  Consumers implement idempotency
  (e2e latency ~ 500ms, based on postgresql ~ 1B events/day/service)
Events: Approach 
  Producers: [31:37]
  Consumers: [32:41]
Events: Schema First [34:02]
Events: Schema Linter [35:19]
Producers: Database Journal [36:12]
Producers: Streams [37:04]
Producing an Event [37:57]
Producers: Testing [38:55]
Consumers: Processing Incoming Events [39:35]
Consumers: Testing [39:56]

Dependencies - Keeping things up to date [40:35]
Dependencies Goal: Automatically update [41:02]
Dependencies: Tracking [42:00]
Dependencies: Updating [43:04]
Dependencies & Continuous Delivery [43:41]

Summary: Critical Decisions [44:00]

@biplobmanna

I know this comment is 4 years too late, but the sheer volume of things I've learnt from this talk tops all the videos/tuts I've watched regarding microservices without debate.

@YouToYoub

This the best presentation I have watched my entire professional life of 22 years. And the best of the 85 videos I have watched on microservices.

@dhiresh5980

One of the things I learnt in this video: Code generation can be used to set strict standards across the systems

@KAUSHIKAKALI

This is the most practical presentation on the quote "Talk is cheap. Show me the code". Finally found something practical otherwise those theoretical rhetoric.

@akinniyiakinyemi2737

I've watched a lot of videos on microservices. This is by far the most sensible, brilliant and cohesive explanation of all! Should be made into a textbook tbh

@jaikantchandrakumaran3423

I loved this talk, not because it is the gold standard but because Michael knows what he is speaking and has taken the efforts to setup the standardisation in every step of the process.

@devrkd

In the entire presentation most of time, it not slides with some block diagrams but real code examples. I really enjoy that. Creating/ investing into such discipline to standardise stuff, you got my respect man.And indeed the code was really beautiful.

@wenhoujx

i watch this video again every year, and every time i learn something new. such a treasure trove. Would love to work with Michael someday, he seems an awesome engineer and an emphatic learder.

@KelvinMeeks

Excellent talk - in particular, note the advice @24:25 - adopting a microservices strategy requires Continuous Deployment

@attilaviniczai7215

Great software design material! It not only covers microservices, but also the devops operations associated to deliver quality software.

@GamerMinecraftivity

It's funny, I keep coming back to this video after studying up on microservices and understanding more and more of why these are good design principles. Great video

@SatyanarayanaBolenedi

I would say, these are Gold Standards of MicroService Architecture From code generation till deployment. Every stage is well designed!!
Thanks a lot Michael Bryzek, you made my day!!

@thesobercoder

My life feels like a lie now when I think about the fact that I know how to write microservices. Absolute gold standard!

@1173mrwan

Their DevOps game is on point

@positivetech

really amazed by - "6 lines of yaml" great effort by folks who automated the default setup.

@peterbodifee

This was an excellent talk (thank you Michael) and he is the living example of how to execute on the principle "if you need to do something more than once, you need to automate." Automation is so much more predictable then humans ;-)

@musicandoutdoors

The way I view this talk is as a representation of the “perfect workflow” for microservices. In my small startup, most of it is “good to know” but I can see adopting things more and more as we grow. Particularly helpful for me was understanding the journaling event publishing aspect. 
The code generation stuff is mind blowing - I would not have thought to automate that much. I wonder how long it took to set that stuff up before they even shipped any product. Yes, now they probably develop lightning fast, but this would be a huge distraction from finding product market fit.

@dmoscrop

Wow, we've basically built this exact thing over the last few years.  It's nice to see this kind of validation.

@andrew5222

I hope everyone understands how brilliant this is