 Hi, I'm Steve Cavallo and I'm going to talk about cross plane and promises. Promise theory is a way we can think about interactions between agents within a system. In promise theory, we say get into the state instead of do this. We're familiar with working the promise theory way, maybe from using chef and puppet and other big management tools, or most likely from using Kubernetes. In Kubernetes, we define and think in terms of end state. In Kubernetes, you don't write a stateful set script, you define and apply a stateful set manifest in Kubernetes promises to attempt to get into your desired state. Kubernetes uses a very literal implementation of promise theory, and many benefits can be realized at scale when promise theory is applied. We can test if we can break things up into small sets of primitives which can be applied independently. How does it all stack up, and how can we apply promise theory to some existing tools. In Terraform, we define our model in HDL, but the challenge in terms of promise theory is, we don't know exactly what our model is until we run a plan or apply to generate it. Until then it's not a true promise. For example, we're creating a spot instance, but we don't know what it will evaluate to until runtime. And in fact, we don't know what it will evaluate to in multiple different environments until runtime. In our second example, we didn't know that this Terraform apply would destroy our resource. Any human invention required makes it difficult to support at scale. With Terraform, there's also no control plane. So there's no guarantee of system state, and we have no way of knowing whether our existing promises are being kept. Where Terraform is great though is determining what changes to enact to bring a system into the desired state. However, at scale. We don't think anything is procedural. And when Terraform must be run in a specific order, or has specific dependencies, it gets very difficult to manage. Taking my previous examples, if a human has to intervene to see if any resources will be changed as part of a deploy, it gets very difficult to, to maintain its scale. CloudFormation allows definition and JSON YAML with very low interpolation. It is much closer to a promise. CloudFormation also has a control plane, so control theory can be applied. We have much better idea of what the state of our system is. So at scale with CloudFormation, we get high predictability of outcome. We have a better model of our end states. We have a control plane that can maintain drift and state. We still have the challenge though when we have many CloudFormation stacks with dependencies and specific orders that it becomes imperative. Crossplane allows definition in JSON YAML. And by nature must be aligned with promise theory because it's a Kubernetes operator. It can be very close to literal interpretation of promise theory. Because it has a controller, it can maintain our state. So as you can see my example, we have controllability, observability, and the controller ensures that we're in our expected state. So at scale, crossplane gives us high predictability of outcomes. In fact, all of its dependencies are promises. You can see in my example, IAM role policy attachment. Policy arm ref is a promise. A role ref is a promise. We no longer have to worry about order. Crossplane will keep retrying until those promises are satisfied. And versioning will allow us to verify which promises are deployed. Now in this screenshot, I have all of my crossplane IAM roles, IAM versions, and visibilities into various environments. So using your favorite flavor of CD, you can get visibility into what versions of the promises exist and whether they're in the promise state or not. In the promise theory, we can think of many, many resources each maintaining a promise state and trusting all the other actors in cooperation and harmony. At scale, we can see crossplane is maintaining all of its promises across multiple systems and much larger systems. So in conclusion, crossplane keeps its promises.