Concentrated Cloud Learning
John and Mike travel the globe to share our knowledge and experience. From the behemoth AWS reInvent, to intimate conversations with startups, we have a passion for helping teams understand the rapidly changing world of Cloud platforms.
We've put together a portfolio of presentations, from introductory overviews to deep technical dives. Please contact us to discuss how we can bring this knowledge to your organization!
What is Serverless? Is it right for your team? In this talk we put on you on a solid path to answering these questions.
Serverless Computing is the latest evolution of Cloud Computing, incorporating third-party “Backend as a Service” (BaaS) services, and/or custom code run in managed, ephemeral containers on a “Functions as a Service” (FaaS) platform. By using these ideas Serverless applications remove much of the need for a traditional always-on server component. Serverless architectures may benefit from significantly reduced operational cost, complexity, and engineering lead time, at a cost of increased reliance on vendor dependencies and comparatively immature supporting services.
In Introduction to Serverless we give an introduction to Serverless techniques, together with examples of the types of application where it is well suited. We then detail the benefits, and limitations, of such an approach, concluding with how we expect Serverless to develop over the coming months and years.
Understand the limitations of a serverless approach, along with a practical set of techniques for dealing with them.
Serverless! It’s a land of rainbows and unicorns and no operations and zero cost and everything just works, right? Hah! No. It has massive benefits, that’s true, but there are some significant traps that can catch you on the way: the flame spurts of unmatched scaling (that’s your database you smell burning); the lightning sand of at-least-once delivery (what do you mean my scheduled task cron-replacement may get called twice?); and of course the R.O.U.S’s (regions of unusual stability).
In Crossing the Serverless Fireswamp we lead you on a warts-and-all journey through some of the limitations of a serverless approach, and share a practical set of techniques for dealing with these concerns.
What is the story of Serverless at this point in time? And where is it going? Gain understanding into this important movement, in order to best place it within your architectural strategy.
In its fairly short time of existence, Serverless has grown from a concept to a fully-fledged movement. What has the Serverless community built and learned in this short history? What is the current state of the art?
More to the point, what is still to be understood, and where lie the significant challenges to mass adoption of Serverless techniques and services? What do we expect to change within the industry over the next year or so? And what will all of this hype lead to in the end?
Despite what you may have heard, Java is often a great language choice for developing AWS Lambda Functions. This talk explains why.
The modern Java Virtual Machine (JVM) is the culmination of millions of hours of expert engineering, and is the foundation on which enormous portions of the digital landscape are built. However, as a runtime for AWS Lambda functions, the JVM is often derided as being a poor fit for an ephemeral world. The truth of the matter is that the JVM is an excellent choice of runtime for a wide range of AWS Lambda use cases, and developers need not even constrain themselves to just the Java language to use it.
In this talk we give an overview of the JVM runtime for AWS Lambda, as well as a comprehensive look at JVM-based Lambda performance across a range of use cases. We outline a set of criteria to help architects and engineers decide whether or not to choose the JVM over the other runtime options. We also give strategies, tips, and examples for developing efficient, performant AWS Lambda functions in a variety of JVM languages, including Java, Clojure, and Scala.
"Real world" applications don't consist of one or two behaviors - they consist of hundreds, thousands, or more. Learn how to build Serverless applications at scale in this deep-dive talk.
The siren song of Serverless lures developers in with promises of “only write business logic” and “deliver value quickly”, but it’s often unclear how to actually work on large-scale, real world Serverless applications, especially in an old-school language like Java. Concerns like incremental builds, configuration management, and continuous delivery are incredibly important. More so than the actual underlying technology, how these process concerns are addressed determines whether your team truly realizes the benefits of a Serverless architecture.
In this talk we builds on the themes of Fearless AWS Lambdas and describe the nuts and bolts of building large-scale Serverless applications using Java. We walk through the efficacy of a Java approach to a variety of Serverless use cases, and via live examples demonstrate pragmatic approaches to developing scalable, evolvable, multi-Lambda applications.
Learn what data pipelines are, why a Serverless approach fits them so well, and how you can build and operate one yourself.
Serverless services are those that fit into the classes of backends as a service (BaaS) (vendor-hosted, highly scalable data and logic components) and functions as a service (FaaS) (the ability to write custom server-side software in small, event-triggered functions, deployed to a fully managed platform). Serverless architectures are those systems that make significant use of either or both of these types of service. Data pipelines are an excellent use case for serverless architecture because of their inherently event-driven behavior and often volatile nature of scaling.
In this talk we describe a real-life example where an existing data platform was rearchitected and reengineered to provide several improvements — significantly increased data capacity, reduced cost, and vastly improved development cycle time — all while reducing operational effort. Such gains were possible by using the vast array of serverless services provided by AWS, such as Kinesis, Lambda, and S3. At the same time, “always on” server components were included within the pipeline where appropriate to create a hybrid architecture of serverless and traditional architecture.
Building such an architecture is just part of the story, of course; running it without headaches is just as crucial. Therefore activities like continuous delivery and monitoring also need to be part of the picture. In this talk we explain how to implement these using further AWS services, including CodePipeline, the Serverless Application Model, and CloudFormation. You’ll learn what is possible when building and running scalable serverless data pipelines on AWS and leave ready to start your own engineering of such systems.
Serverless Computing offers the benefits of accelerated delivery and reduced operations costs. However it also brings tooling and architectural challenges. What are safe, yet effective, methods to introduce Serverless to your organization? We discuss several alternatives, from our experience with teams that have faced this precise question.
Serverless Computing is a trend within Cloud computing that embraces the use of fully-managed vendor services. Such vendor products include ephemeral ‘Functions-as-a-Service’ platforms, as well as externalized application components such as databases, user management, and artificial intelligence.
While the primary benefits of Serverless are a further progression of the Cloud in general - cheaper operations, and reduced time-to-market - it requires a different architectural and operational mindset to many other software design models, and furthermore the patterns and tools around Serverless are still to fully mature. Because of these concerns, and others, many organizations are reticent to embrace Serverless, preferring to wait for current adopters to tease out better practices and understanding.
But for those willing to embrace their adventurous side what are good ways to start embracing these technologies? And how can the benefits of Serverless be embraced safely? And most importantly, what are experiments that a company can perform that provide intrinsic value, yet also provide a chance to learn?
In this talk we provide a catalogue of ideas for trying Serverless, as well as a framework for evaluating their effectiveness within your organization.
Understand the capabilities of radically changing our product development processes, by the power of DevOps Culture, Serverless, and a few friends.
Over the last 20 years we’ve seen the lead time for delivering software decrease from years to weeks. Now we see an opportunity to reduce this further to days or even hours. This enables us to think about how we approach product development in a new way – one of “Continuous Experimentation”. What advantages, and what challenges, does such a way of working bring?
In this talk we drill into the benefits that the combination of DevOps, Serverless technology, “Modern Agile”, and a few other ideas can bring to accelerating how we work. Through this we show how Continuous Experimentation might just be the next big change in the way we deliver software.
Please email us at firstname.lastname@example.org, or fill out the form below. We look forward to hearing from you!