Product Guy, Serverless Advocate & Startup Veteran

My name is Jeremy Daly. I appreciate the visit. 👍 I’ve been managing the development of complex web and mobile applications for businesses across the globe for over 20 years. I’m currently the Chief Technology Officer at AlertMe, but I always keep myself busy with several side projects and consulting clients. I’m also an AWS Serverless Hero.

I write a lot about serverless and I like to share thoughts and stories about programmingproduct managemententrepreneurship and productivity. Sometimes I’ll write reviews or have random thoughts that I need to get out of my head. I also like to post a how-to article every once in a while. Feel free to jump in to one of the categories above, view all my posts, or view my latest posts below.

If you want to keep up with what I’m working on, you can follow me on TwitterGithub and Facebook.

Also, if you’re interested in serverless, please subscribe to Off-by-none, a weekly newsletter that focuses on all things serverless, and be sure to listen to Serverless Chats, a weekly podcast that discusses all things serverless.

My Latest Posts:

🚀 Project Update:

Lambda API: v0.10.2 Released

Lambda API v0.10.2 has been released to add additional TypeScript support (@maxmellen), fix an issue with multiValueHeaders containing a null value (@stawecki), and support for overriding console.log for logging output (@Sleavely). Read More...
🚀 Project Update:

Serverless MySQL: v1.5.0 released

Serverless MySQL v1.5.0 is a maintenance/security update that also adds a new feature to transaction handling allowing you to return null queries to simplify conditional transaction workflows. Read More...

How to switch from RDBMS to DynamoDB in 20 easy steps…

I posted a thread on Twitter with some thoughts on how to how to switch from RDBMS to DynamoDB. Some people have asked me to turn it into a blog post to make it easier to follow. So here it is… with some bonus steps at the end. Enjoy! 😁

Continue Reading…

🚀 Project Update:

Serverless MySQL: v1.4.0 Released

Thanks to contributions from the community, Serverless MySQL v1.4.0 adds the ability to bring your own MySQL and Promise libraries, an enhancement that lets you use multiple instances, and some more TypeScript updates. Read More...

Developing Serverless Applications Locally with the “serverless-cloudside-plugin”

Developing and testing serverless applications locally can be a challenge. Even with tools like SAM and the Serverless Framework, you often end up mocking your cloud resources, or resorting to tricks (like using pseudo-variables) to build ARNs and service endpoint URLs manually. While these workarounds may have the desired result, they also complicate our configuration files with (potentially brittle) user-constructed strings, which duplicates information already available to CloudFormation.

This is a common problem for me and other serverless developers I know. So I decided to come up with a solution.

Continue Reading…

🚀 Project Update:

Lambda API: v0.10.1 Released

Lambda API v0.10.1 has been released to fix an issue with the "statusCode" reporting incorrectly in error logs. The arity requirement for handler functions has also been relaxed since it's possible that they may not be needed within a route definition. Read More...

Throttling Third-Party API calls with AWS Lambda

In the serverless world, we often get the impression that our applications can scale without limits. With the right design (and enough money), this is theoretically possible. But in reality, many components of our serverless applications DO have limits. Whether these are physical limits, like network throughput or CPU capacity, or soft limits, like AWS Account Limits or third-party API quotas, our serverless applications still need to be able to handle periods of high load. And more importantly, our end users should experience minimal, if any, negative effects when we reach these thresholds.

There are many ways to add resiliency to our serverless applications, but this post is going to focus on dealing specifically with quotas in third-party APIs. We’ll look at how we can use a combination of SQS, CloudWatch Events, and Lambda functions to implement a precisely controlled throttling system. We’ll also discuss how you can implement (almost) guaranteed ordering, state management (for multi-tiered quotas), and how to plan for failure. Let’s get started!

Continue Reading…

How To: Use SNS and SQS to Distribute and Throttle Events

An extremely useful AWS serverless microservice pattern is to distribute an event to one or more SQS queues using SNS. This gives us the ability to use multiple SQS queues to “buffer” events so that we can throttle queue processing to alleviate pressure on downstream resources. For example, if we have an event that needs to write information to a relational database AND trigger another process that needs to call a third-party API, this pattern would be a great fit.

This is a variation of the Distributed Trigger Pattern, but in this example, the SNS topic AND the SQS queues are contained within a single microservice. It is certainly possible to subscribe other microservices to this SNS topic as well, but we’ll stick with intra-service subscriptions for now. The diagram below represents a high-level view of how we might trigger an SNS topic (API Gateway → Lambda → SNS), with SNS then distributing the message to the SQS queues. Let’s call it the Distributed Queue Pattern.

Distributed Queue Pattern

This post assumes you know the basics of setting up a serverless application, and will focus on just the SNS topic subscriptions, permissions, and implementation best practices. Let’s get started!

Continue Reading…

🚀 Project Update:

Lambda API: v0.10 Released

Lambda API v0.10 adds the ability for you to seamlessly switch your Lambdas between API Gateway and Application Load Balancers. New execution stacks enables method-based middleware and more wildcard functionality. Plus full support for multi-value headers and multi-value query string parameters. Read More...

Stop Calling Everything Serverless!

I’ve been building serverless applications since AWS Lambda went GA in early 2015. I’m not saying that makes me an expert on the subject, but as I’ve watched the ecosystem mature and the community expand, I have formed some opinions around what it means exactly to be “serverless.” I often see tweets or articles that talk about serverless in a way that’s, let’s say, incompatible with my interpretation. This sometimes makes my blood boil, because I believe that “serverless” isn’t a buzzword, and that it actually stands for something important.

I’m sure that many people believe that this is just a semantic argument, but I disagree. When we refer to something as being “serverless”, there should be an agreed upon understanding of not only what that means, but also what it empowers you to do. If we continue to let marketers hijack the term, then it will become a buzzword with absolutely no discernible meaning whatsoever. In this post, we’ll look at how some leaders in the serverless space have defined it, I’ll add some of my thoughts, and then offer my own definition at the end.

Continue Reading…

Serverless Tip: Don’t overpay when waiting on remote API calls

Our serverless applications become a lot more interesting when they interact with third-party APIs like Twilio, SendGrid, Twitter, MailChimp, Stripe, IBM Watson and others. Most of these APIs respond relatively quickly (within a few hundred milliseconds or so), allowing us to include them in the execution of synchronous workflows (like our own API calls).  Sometimes we run these calls asynchronously as background tasks completely disconnected from any type of front end user experience.

Regardless how they’re executed, the Lambda functions calling them need to stay running while they wait for a response. Unfortunately, Step Functions don’t have a way to create HTTP requests and wait for a response. And even if they did, you’d at least have to pay for the cost of the transition, which can get a bit expensive at scale. This may not seem like a big deal on the surface, but depending on your memory configuration, the cost can really start to add up.

In this post we’ll look at the impact of memory configuration on the performance of remote API calls, run a cost analysis, and explore ways to optimize our Lambda functions to minimize cost and execution time when dealing with third-party APIs.

Continue Reading…

re:Capping re:Invent: AWS goes all-in on Serverless

Last week I spent six incredibly exhausting days in Las Vegas at the AWS re:Invent conference. More than 50,000 developers, partners, customers, and cloud enthusiasts came together to experience this annual event that continues to grow year after year. This was my first time attending, and while I wasn’t quite sure what to expect, I left with not just the feeling that I got my money’s worth, but that AWS is doing everything in their power to help customers like me succeed.

There have already been some really good wrap-up posts about the event. Take a look at James Beswick’s What I learned from AWS re:Invent 2018, Paul Swail’s What new use cases do the re:Invent 2018 serverless announcements open up?, and All the Serverless announcements at re:Invent 2018 from the Serverless, Inc. blog. There’s a lot of good analysis in these posts, so rather than simply rehash everything, I figured I touch on a few of the announcements that I think really matter. We’ll get to that in a minute, but first I want to point out a few things about Amazon Web Services that I learned this past week.

Continue Reading…

Aurora Serverless Data API: An (updated) First Look

Update June 5, 2019: The Data API team has released another update that adds improvements to the JSON serialization of the responses. Any unused type fields will be removed, which makes the response size 80+% smaller.

Update June 4, 2019: After playing around with the updated Data API, I found myself writing a few wrappers to handle parameter formation, transaction management, and response formatting. I ended up writing a full-blown client library for it. I call it the “Data API Client“, and it’s available now on GitHub and NPM.

Update May 31, 2019: AWS has released an updated version of the Data API (see here). There have been a number of improvements (especially to the speed, security, and transaction handling). I’ve updated this post to reflect the new changes/improvements.

On Tuesday, November 20, 2018, AWS announced the release of the new Aurora Serverless Data API. This has been a long awaited feature and has been at the top of many a person’s #awswishlist. As you can imagine, there was quite a bit of fanfare over this on Twitter.

Obviously, I too was excited. The prospect of not needing to use VPCs with Lambda functions to access an RDS database is pretty compelling. Think about all those cold start savings. Plus, connection management with serverless and RDBMS has been quite tricky. I even wrote an NPM package to help deal with the max_connections issue and the inevitable zombies 🧟‍♂️ roaming around your RDS cluster. So AWS’s RDS via HTTP seems like the perfect solution, right? Well, not so fast. 😞 (Update May 31, 2019: There have been a ton of improvements, so read the full post.)

Continue Reading…

🚀 Project Update:

Lambda API: v0.9.2 Released

Lambda API v0.9.2 has been released and contains additional updates and fixes for the index.d.ts TypeScript declarations file. Thanks again to @hassankhan and @Wintereise for submitting the changes. The release is immediately available via NPM. Read More...
🚀 Project Update:

Lambda API: v0.9.1 Released

Lambda API v0.9.1 has been released to include the index.d.ts TypeScript declarations file in the NPM package (thanks again, @hassankhan). The release is immediately available via NPM. Read More...
🚀 Project Update:

Lambda API: v0.9 Released

v0.9 adds new features to give developers better control over error handling and serialization. A TypeScript declaration file has also been added along with some additional API Gateway inputs that are now available in the REQUEST object. Read More...

Takeaways from ServerlessNYC 2018

I had the opportunity to attend ServerlessNYC this week (a ServerlessDays community conference) and had an absolutely amazing time. The conference was really well-organized (thanks Iguazio), the speakers were great, and I was able to have some very interesting (and enlightening) conversations with many attendees and presenters. In this post I’ve summarized some of the key takeaways from the event as well as provided some of my own thoughts.

Note: There were several talks that were focused on a specific product or service. While I found these talks to be very interesting, I didn’t include them in this post. I tried to cover the topics and lessons that can be applied to serverless in general.

Update November 16, 2018: Some videos have been posted, so I’ve provided the links to them.

Audio Version:

Continue Reading…

What 15 Minute Lambda Functions Tells Us About the Future of Serverless

Amazon Web Services recently announced that they increased the maximum execution time of Lambda functions from 5 to 15 minutes. In addition to this, they also introduced the new “Applications” menu in the Lambda Console, a tool that aggregates functions, resources, event sources and metrics based on services defined by SAM or CloudFormation templates. With AWS re:Invent just around the corner, I’m sure these announcements are just the tip of the iceberg with regards to AWS’s plans for Lambda and its suite of complementary managed services.

While these may seem like incremental improvements to the casual observer, they actually give us an interesting glimpse into the future of serverless computing. Cloud providers, especially AWS, continue to push the limits of what serverless can and should be. In this post, we’ll discuss why these two announcements represent significant progress into serverless becoming the dominant force in cloud computing.

Continue Reading…

🚀 Project Update:

Lambda API: v0.8.1 Released

Lambda API v0.8.1 has been released to patch an issue with middleware responses and a path prefixing options bug. The release is immediately available via NPM. Read More...

An Introduction to Serverless Microservices

Thinking about microservices, especially their communication patterns, can be a bit of a mind-bending experience for developers. The idea of splitting an application into several (if not hundreds of) independent services, can leave even the most experienced developer scratching their head and questioning their choices. Add serverless event-driven architecture into the mix, eliminating the idea of state between invocations, and introducing a new per function concurrency model that supports near limitless scaling, it’s not surprising that many developers find this confusing. 😕 But it doesn’t have to be. 😀

In this post, we’ll outline a few principles of microservices and then discuss how we might implement them using serverless. If you are familiar with microservices and how they communicate, this post should highlight how these patterns are adapted to fit a serverless model. If you’re new to microservices, hopefully you’ll get enough of the basics to start you on your serverless microservices journey. We’ll also touch on the idea of orchestration versus choreography and when one might be a better choice than the other with serverless architectures. I hope you’ll walk away from this realizing both the power of the serverless microservices approach and that the basic fundamentals are actually quite simple.  👊

Audio Version:

Continue Reading…

🚀 Project Update:

Serverless MySQL: v1.1.0 Released

Serverless MySQL v1.1.0 adds additional transaction support capabilities to allow users to retrieve interim query results for use with future queries. This is useful for getting the insertId from previous queries when performing transactions. Read More...

Serverless Security: Locking Down Your Apps with FunctionShield

I’ve written quite extensively about serverless security, and while you don’t need to be an expert on the matter, there are a number of common sense principles that every developer should know. Serverless infrastructures (specifically FaaS and managed services) certainly benefit from an increased security posture given that the cloud provider is handling things like software patching, network security, and to some extent, even DDoS mitigation. But at the end of the day, your application is only as secure as its weakest link, and with serverless, that pretty much always comes down to application layer security.

In this post we’re going to look at ways to mitigate some of these application layer security issues by using some simple strategies as well as a free tool called FunctionShield.

Audio Version:

Continue Reading…

Managing MySQL at Serverless Scale

“What? You can’t use MySQL with serverless functions, you’ll just exhaust all the connections as soon as it starts to scale! And what about zombie connections? Lambda doesn’t clean those up for you, meaning you’ll potentially have hundreds of sleeping threads blocking new connections and throwing errors. It can’t be done!”  ~ Naysayer

I really like DynamoDB and BigTable (even Cosmos DB is pretty cool), and for most of my serverless applications, they would be my first choice as a datastore. But I still have a love for relational databases, especially MySQL. It had always been my goto choice, perfect for building normalized data structures, enforcing declarative constants, providing referential integrity, and enabling ACID-compliant transactions. Plus the elegance of SQL (structured query language) makes organizing, retrieving and updating your data drop dead simple.

But now we have SERVERLESS. And Serverless functions (like AWS Lambda, Google Cloud Functions, and Azure Functions) scale almost infinitely by creating separate instances for each concurrent user. This is a MAJOR PROBLEM for RDBS solutions like MySQL, because available connections can be quickly maxed out by concurrent functions competing for access. Reusing database connections doesn’t help, and even the release of Aurora Serverless doesn’t solve the max_connections problem. Sure there are some tricks we can use to mitigate the problem, but ultimately, using MySQL with serverless is a massive headache.

Well, maybe not anymore. 😀 I’ve been dealing with MySQL scaling issues and serverless functions for years now, and I’ve finally incorporated all of my learning into a simple, easy to use NPM module that (I hope) will solve your Serverless MySQL problems.

Continue Reading…

Jeremy goes to AWS re:Invent 2018

It’s official! I’m going to AWS re:Invent 2018. 🙌

My goal from this trip is to learn, learn, learn… and then share, share, share.   There are over 30 sessions that talk about serverless, plus 40,000 other people there to meet and learn from! I’m so excited. 🙃

I know that many of you will be there, but for those of you who can’t be, I’ll do my best to share insights, tips, how-tos, best practices and more. I’ll even have a drink for you if you’d like 🍺 (no arm twisting necessary)!

Continue Reading…

Serverless Microservice Patterns for AWS

I’m a huge fan of building microservices with serverless systems. Serverless gives us the power to focus on just the code and our data without worrying about the maintenance and configuration of the underlying compute resources. Cloud providers (like AWS), also give us a huge number of managed services that we can stitch together to create incredibly powerful, and massively scalable serverless microservices.

I’ve read a lot of posts that mention serverless microservices, but they often don’t go into much detail. I feel like that can leave people confused and make it harder for them to implement their own solutions. Since I work with serverless microservices all the time, I figured I’d compile a list of design patterns and how to implement them in AWS. I came up with 19 of them, though I’m sure there are plenty more.

In this post we’ll look at all 19 in detail so that you can use them as templates to start designing your own serverless microservices.

Audio Version:

Continue Reading…

🚀 Project Update:

Lambda API: v0.8 Released

Lambda v0.8 is finally here and was well worth the wait! New features include allowing middleware to accept multiple handlers, new convenience methods for cache control and signing S3 URLs, and async/await support for the main function handler. And best of all, new LOGGING and SAMPLING support for you to add more observability into your APIs and web applications. Read More...

Aurora Serverless: The Good, the Bad and the Scalable

Amazon announced the General Availability of Aurora Serverless on August 9, 2018. I have been playing around with the preview of Aurora Serverless for a few months, and I must say that overall, I’m very impressed. There are A LOT of limitations with this first release, but I believe that Amazon will do what Amazon does best, and keep iterating until this thing is rock solid.

The announcement gives a great overview and the official User Guide is chock full of interesting and useful information, so I definitely suggest giving those a read. In this post, I want to dive a little bit deeper and discuss the pros and cons of Aurora Serverless. I also want to dig into some of the technical details, pricing comparisons, and look more closely at the limitations.

Audio Version

Continue Reading…

A Tale of Two Teams

Audio Version:

It was the best of times, it was the worst of times, it was the age of wisdom, it was the age of foolishness… ~ A Tale of Two Cities by Charles Dickens

There is a revolution happening in the tech world. An emerging paradigm that’s letting development teams focus on business value instead of technical orchestration. It is helping teams create and iterate faster, without worrying about the limits or configurations of an underlying infrastructure. It is enabling the emergence of new tools and services that foster greater developer freedom. Freedom to experiment. Freedom to do more with less. Freedom to immediately create value by publishing their work without the traditional barriers created by operational limits.

Continue Reading…

How To: Add Test Coverage to your Serverless Applications

Writing serverless functions brings developers closer and closer to the stack that runs their code. While this gives them a tremendous amount of freedom, it also adds additional responsibility. Serverless applications require developers to think more about security and optimizations, as well as perform other tasks that were traditionally assigned to operations teams. And of course, code quality and proper testing continue to be at the top of the list for production-level applications. In this post, we’ll look at how to add test coverage to our Node.js applications and how we can apply it to our Serverless framework projects. ⚡️

Continue Reading…

Serverless Peeps You Need To Follow

In my never ending quest to consume all things serverless, I often find myself scouring the Interwebs for new and interesting serverless articles, blog posts, videos, and podcasts. There are more and more people doing fascinating things with serverless every day, so finding content is becoming easier and easier. However, this increase in content comes with an increase in noise as well. Cutting through that noise isn’t always easy. 🙉

Great content with valuable insights

I personally love reading articles that introduce new use cases or optimizations for serverless. Stories about companies using serverless in production and how their architectures are set up are also extremely interesting. I’ve been working in the serverless space for several years now, and have come across a number of people who produce and/or share really great content. I’ve put together a list of people that I follow and enjoy their content regularly. Hopefully these people will help you learn to love serverless as much as I do. ❤️⚡️

Continue Reading…

How To: Tag Your Lambda Functions for Smarter Serverless Applications

As our serverless applications start to grow in complexity and scope, we often find ourselves publishing dozens if not hundreds of functions to handle our expanding workloads. It’s no secret that serverless development workflows have been a challenge for a lot of organizations. Some best practices are starting to emerge, but many development teams are simply mixing their existing workflows with frameworks like Serverless and AWS SAM to build, test and deploy their serverless applications.

Beyond workflows, another challenge serverless developers encounter as their applications expand, is simply trying to keep all of their functions organized. You may have several functions and resources as part of a microservice contained in their own git repo. Or you might simply put all your functions in a single repository for better common library sharing. Regardless of how code is organized locally, much of that is lost when all your functions end up in a big long list in the AWS Lambda console. In this post we’ll look at how we can use AWS’s resource tagging as a way to apply structure to our deployed functions. This not only give us more insight into our applications, but can be used to apply Cost-Allocation Tags to our billing reports as well. 👍

Continue Reading…

Thinking Serverless (Big and Small)

I’ve been reading and writing a lot of about serverless lately, and one of the things I realized, is that most articles talk about how SCALABLE serverless architectures are. This, of course, is one of the major benefits of using serverless to build your applications. The ability to scale to thousands of concurrent requests per second without needing to manage your own servers, is simply amazing. 🙌

However, not needing to manage any servers has other benefits beyond the capabilities to achieve web scale. Having on-demand compute space also make serverless the perfect candidate for smaller workloads. In this post, let’s discuss how we can utilize serverless to handle our “less than unicorn 🦄” services and the benefits this can bring.

Continue Reading…

Lambda Warmer: Optimize AWS Lambda Function Cold Starts

At a recent AWS Startup Day event in Boston, MA, Chris Munns, the Senior Developer Advocate for Serverless at AWS, discussed Lambda cold starts and how to mitigate them. According to Chris (although he acknowledge that it is a “hack”) using the CloudWatch Events “ping” method is really the only way to do it right now. He gave a number of really good tips to pre-warm your functions “correctly”:

  • Don’t ping more often than every 5 minutes
  • Invoke the function directly (i.e. don’t use API Gateway to invoke it)
  • Pass in a test payload that can be identified as such
  • Create handler logic that replies accordingly without running the whole function

Continue Reading…

15 Key Takeaways from the Serverless Talk at AWS Startup Day

I love learning about the capabilities of AWS Lambda functions, and typically consume any article or piece of documentation I come across on the subject. When I heard that Chris Munns, Senior Developer Advocate for Serverless at AWS, was going to be speaking at AWS Startup Day in Boston, I was excited. I was able to attend his talk, The Best Practices and Hard Lessons Learned of Serverless Applications, and it was well worth it.

Chris said during his talk that all of the information he presented is on the AWS Serverless site. However, there is A LOT of information out there, so it was nice to have him consolidate it down for us into a 45 minute talk. There was some really insightful information shared and lots of great questions. I was aware of many of the topics discussed, but there were several clarifications and explanations (especially around the inner workings of Lambda) that were really helpful. 👍

Continue Reading…

Mixing VPC and Non-VPC Lambda Functions for Higher Performing Microservices

I came across a post the in the Serverless forums that asked how to disable the VPC for a single function within a Serverless project. This got me thinking about how other people structure their serverless microservices, so I wanted to throw out some ideas. I often mix my Lambda functions between VPC and non-VPC depending on their use and data requirements. In this post, I’ll outline some ways you can structure your Lambda microservices to isolate services, make execution faster, and maybe even save you some money. ⚡️💰

Continue Reading…

5 Reasons Why Your Serverless Application Might Be A Security Risk

There has been a lot of buzz lately about serverless security. People are certainly talking about it more and sharing great articles on the topic, but many serverless developers (especially new ones) are still making the same critical mistakes. Every time a serverless function is deployed, its unique security challenges need to be addressed. Every time. I’ve researched and written extensively about serverless security (see Securing Serverless: A Newbie’s Guide). I’ve read countless articles on the subject. And while there is no shortage of information available, let’s be honest: developers are busy building applications, not pouring through hundreds of articles.

I know, it sounds boring, but I would encourage you to do your research on serverless security. Serverless applications are different than traditional, server-hosted applications. Much of the security responsibility falls on the developer, and not following best practices opens you (or your company) up to an attack. But I know you’re busy. I totally get it. So rather than forcing you to read a bunch of long articles 😴 or watch a plethora of videos 🙈, I’ve whittled it all down to the five biggest serverless security risks for you. Sure, there are a lot of other things to consider, but IMO, these are the most important ones. Nothing here hasn’t been said before. But If you do nothing more than follow these principles, your serverless applications will be much more secure. 🔒

Continue Reading…

Serverless Consumers with Lambda and SQS Triggers

On Wednesday, June 27, 2018, Amazon Web Services released SQS triggers for Lambda functions. Those of you who have been building serverless applications with AWS Lambda probably know how big of a deal this is. Until now, the AWS Simple Queue Service (SQS) was generally a pain to deal with for serverless applications. Communicating with SQS is simple and straightforward, but there was no way to automatically consume messages without implementing a series of hacks. In general, these hacks “worked” and were fairly manageable. However, as your services became more complex, dealing with concurrency and managing fan out made your applications brittle and error prone. SQS triggers solve all of these problems. 👊

Update December 6, 2018: At some point over the last few months AWS fixed the issue with the concurrency limits and the redrive policy. See Additional experiments with concurrency and redrive polices below.

Audio Version (please note that this audio version is out of date given the new updates)

Continue Reading…

Event Injection: Protecting your Serverless Applications

Updated January 25, 2019: This post was updated based on feedback from the community.

The shared security model of cloud providers extends much further with serverless offerings, but application security is still the developer’s responsibility. Many traditional web applications are front-ended with WAFs (web application firewalls), RASPs (runtime application self-protection), EPPs (endpoint protection platforms) and WSGs (web security gateways) that inspect incoming and outgoing traffic. These extra layers of protection can save developers from themselves when making common programming mistakes that would otherwise leave their applications vulnerable. If you’re invoking serverless functions from sources other than API Gateway, you no longer have the ability to use the protection of a WAF. 

Continue Reading…

10 Things You Need To Know When Building Serverless Applications

I am a HUGE fan of serverless architectures. This new type of compute not only opens up more possibilities for developers, but can support highly-scalable, complex applications for a fraction of the cost compared to provisioning virtual servers. My first question when planning a new application is always, “Can I build this with serverless?” Spoiler alert, the answer is almost always YES!

I’ve been building serverless applications since the release of AWS Lambda in 2015, so answering the question above is pretty easy for me. However, a lot of people I talk to who are new to serverless often have many questions (and misconceptions). I want you to be successful, so below I’ve create a list of 10 things you need to know when building a serverless application. These are things I wish I knew when I started, so hopefully they’ll help you get up to speed a faster and start building some amazing applications.

Continue Reading…

🚀 Project Update:

Lambda API: v0.7 Released

v0.7 adds new features to control middleware execution based on path, plus additional parsing of the AWS Lambda context object. ESLint and coverage reports using Istanbul and Coveralls were also added to ensure code quality and adequate test coverage. Read More...

How To: Optimize the Serverless Optimizer Plugin

I’m sure you’re already well aware of how awesome the ⚡ Serverless Framework is for managing and deploying your serverless applications. And you’re probably aware that there are several great plugins available that make Serverless even better. But did you know that there was a plugin to optimize your functions and reduce the size of your deployment packages? Or are you already using this plugin to optimize your functions, but hate how it takes too long to optimize locally run functions? In this post I’ll share some quick tips to help you optimize your Serverless Optimizer experience.

Continue Reading…

Transducers: Supercharge your functional JavaScript

This is the first in a series of posts on functional programming in JavaScript. My goal is to make these ideas more accessible to all levels of programmers. Feedback about style, content, etc., would all be greatly appreciated.

One thing that perplexed me early on in my functional programming days was the concept of transducers. I spent a lot of time Googling and found some great articles that went deep into the theory and the underlying mechanics. However, the practical use of them still seemed a bit out of reach. In this post I’ll attempt to explain transducers in a more understandable way and hopefully give you the confidence to use them in your functional JavaScript. While this article attempts to make transducers more accessible, you will need to have some basic knowledge of functional programming in JavaScript. Specifically, you should know about function composition and iterator functions like .map(), .filter(), and most importantly, .reduce(). If you are unfamiliar with these concepts, go get a grasp on them first.

Continue Reading…

🚀 Project Update:

Lambda API: v0.6 Released

v0.6 is all about making the serverless developer's life easier! New support for both callback-style and async-await in route functions and middleware, new HTTP method routing features, and route debugging tools. Plus Etag support and automatic authorization parsing. Read More...

Solving the Cold Start Problem

Dear AWS Lambda Team,

I have a serious problem: I love AWS Lambda! In fact, I love it so much that I’ve pretty much gone all in on this whole #serverless thing. I use Lambda for almost everything now. I use it to build backend data processing pipelines, distribute long running tasks, and respond to API requests. Heck, I even built an Alexa app just for fun. I found myself building so many RESTful APIs using Lambda and API Gateway that I went ahead and created the open source Lambda API web framework to allow users to more efficiently route and respond to API Gateway requests.

Serverless technologies, like Lambda, have revolutionized how developers think about building applications. Abstracting away the underlying compute layer and replacing it with on-demand, near-infinitely scalable function containers is brilliant. As we would say out here in Boston, “you guys are wicked smaht.” But I think you missed something very important. In your efforts to conform to the “pay only for the compute time you consume” promise of serverless, you inadvertently handicapped the service. My biggest complaint, and the number one objection that I hear from most of the “serverless-is-not-ready-for-primetime” naysayers, are Cold Starts.

Continue Reading…

How To: Manage Serverless Environment Variables Per Stage

I often find myself creating four separate stages for each ⚡ Serverless Framework project I work on: dev, staging, prod, and local. Obviously the first three are meant to be deployed to the cloud, but the last one, local, is meant to run and test interactions with local resources. It’s also great to have an offline version (like when you’re on a plane ✈ or have terrible wifi somewhere). Plus, development is much faster because you’re not waiting for round trips to the server. 😉

A really great feature of Serverless is the ability to configure ENVIRONMENT variables in the serverless.yml file. This lets us store important global information like database names, service endpoints and more. We can even reference passwords securely using AWS’s Service Manager Parameter Store and decode encrypted secrets on deployment, keeping them safe from developers and source repositories alike. 😬 Just reference the variable with ${ssm:/myapp/my-secure-value~true} in your configuration file.

Continue Reading…

🚀 Project Update:

Lambda API: v0.5 Released

v0.5 takes advantage of AWS Lambda's recently released support for Node v8.10 and has removed its Bluebird promise dependency in favor of async/await. Lambda API is now faster and adds built-in CORS support, additional wildcard features, new HTTP header management methods and more. Read More...

How To: Stub “.promise()” in AWS-SDK Node.js

Since AWS released support for Node v8.10 in Lambda, I was able to refactor Lambda API to use async/await instead of Bluebird promises. The code is not only much cleaner now, but I was able to remove a lot of unnecessary overhead as well. As part of the refactoring, I decided to use AWS-SDK’s native promise implementation by appending .promise() to the end of an S3 getObject call. This works perfectly in production and the code is super compact and simple:

The issue came with stubbing the call using Sinon.js. With the old promise method, I was using promisifyAll() to wrap new AWS.S3() and then stubbing the getObjectAsync method. If you’re not familiar with stubbing AWS services, read my post: How To: Stub AWS Services in Lambda Functions using Serverless, Sinon.JS and Promises.

Continue Reading…

How To: Manage RDS Connections from AWS Lambda Serverless Functions

Someone asked a great question on my How To: Reuse Database Connections in AWS Lambda post about how to end the unused connections left over by expired Lambda functions:

I’m playing around with AWS lambda and connections to an RDS database and am finding that for the containers that are not reused the connection remains. I found before that sometimes the connections would just die eventually. I was wondering, is there some way to manage and/or end the connections without needing to wait for them to end on their own? The main issue I’m worried about is that these unused connections would remain for an excessive amount of time and prevent new connections that will actually be used from being made due to the limit on the number of connections.

🧟‍♂️ Zombie RDS connections leftover on container expiration can become a problem when you start to reach a high number of concurrent Lambda executions. My guess is that this is why AWS is launching Aurora Serverless, to deal with relational databases at scale. At the time of this writing it is still in preview mode.

Update September 2, 2018: I wrote an NPM module that manages MySQL connections for you in serverless environments. Check it out here.

Update August 9, 2018: Aurora Serverless is now Generally Available!

Overall, I’ve found that Lambda is pretty good about closing database connections when the container expires, but even if it does it reliably, it still doesn’t solve the MAX CONNECTIONS problem. Here are several strategies that I’ve used to deal with this issue.

Continue Reading…

Is Code Really Self-Documenting?

In my 20+ years of programming, I’ve encountered a near endless amount of opinions on everything from coding styles to programming paradigms to the great whitespace debate. Obviously, I have strong opinions on a number of these. But for me, the one that bothers me the most is this notion that “code is self-documenting.” 😾

I know what you’re probably thinking: “of course not all code is self-documenting, only well-written code is.” I don’t entirely disagree. I can generally look at someone else’s code and understand exactly WHAT it is doing. However, often it’s not obvious WHY they did it that way, or even why they did it in the first place. In my opinion, the programmer’s intent (the WHY) is just as important as the HOW when it comes to properly documenting software.

So whether you agree with me or not, let’s explore how to better document our software by writing cleaner code, following some general commenting etiquette, and commenting more effectively to make you and your team more productive. 👍

Continue Reading…

Securing Serverless: A Newbie’s Guide

So you’ve decided to build a serverless application. That’s awesome! May I be the first to welcome you to the future. 🤖 I bet you’ve done a lot of research. You’ve probably even deployed a few test functions to AWS Lambda or Google Cloud Functions and you’re ready to actually build something useful. You probably still have a bunch of unanswered questions, and that’s cool. We can still build some really great applications even if we only know the basics. However, when we start working with new things we typically make a bunch of dumb mistakes. While some are relatively innocuous, security mistakes can cause some serious damage.

I’ve been working with serverless applications since AWS launched Lambda in early 2015. Over the last few years I’ve developed many serverless applications covering a wide range of use cases. The most important thing I’ve learned: SECURE YOUR FUNCTIONS! I can tell you from personal experience, getting burned by an attack is no bueno. I’d hate to see it happen to you. 😢

To make sure it doesn’t happen to you, I’ve put together a list of 🔒Serverless Security Best Practices. This is not a comprehensive list, but it covers the things you ABSOLUTELY must do. I also give you some more things to think about as you continue on your serverless journey. 🚀

Continue Reading…

How To: Build a Serverless API with Serverless, AWS Lambda and Lambda API

AWS Lambda and AWS API Gateway have made creating serverless APIs extremely easy. Developers can simply create Lambda functions, configure an API Gateway, and start responding to RESTful endpoint calls. While this all seems pretty straightforward on the surface, there are plenty of pitfalls that can make working with these services frustrating.

There are, for example, lots of confusing and conflicting configurations in API Gateway.  Managing deployments and resources can be tricky, especially when publishing to multiple stages (e.g. dev, staging, prod, etc.). Even structuring your application code and dependencies can be difficult to wrap your head around when working with multiple functions.

In this post I’m going to show you how to setup and deploy a serverless API using the Serverless framework and Lambda API, a lightweight web framework for your serverless applications using AWS Lambda and API Gateway. We’ll create some sample routes, handle CORS, and discuss managing authentication. Let’s get started.

Continue Reading…

Off-by-none: Issue #59

#ServerlessForEveryone 🙌

Welcome to Issue #59 of Off-by-none. Thanks for being with us! 🤘🏻

Last week, we were at Serverlessconf NYC, having some awesome conversations with some pretty smart serverless people. This week, we’ve got lots of great AWS re:Invent news, and we’ll learn how AWS built a production service using serverless technologies. Plus, we’ve got plenty of great serverless content from the community.

Lots to share this week, so let’s get to it! 👍

How does AWS build their serverless applications?

How AWS Built a Production Service Using Serverless Technologies
If you’ve ever wondered how AWS built a serverless application for itself, this post will tell you almost everything you need to know. This is a super in-depth look (including the open-source repo) of the SAM templates, file structure, CI/CD process, parameter management, and much more.

Examining how AWS builds their own serverless apps
And if you want to get some additional insights from another serverless pro, check out Forrest Brazeal’s commentary on what AWS has provided.

If you’re going to re:Invent, you don’t want to miss this…

AWS re:Invent is less than 50 days away, and reserved seating just opened this morning. Hopefully you’ve already booked some great serverless sessions, but if you are still looking for some more ideas, these guides should definitely help:

Also, if you want to meet up with all the people building the foundation of the serverless ecosystem, make sure you check out the #ServerlessForEveryone Community Party @ AWS re:Invent 2019. This event is only possible because of our amazing sponsors: Stackery, Thundra, AWS, CloudZero, Lumigo, and Protego. I hope you’ll join us!

Serverless News & Product Announcements 🚀

Serverless Networking: The next step in Serverless Evolution
No, seriously, peer-to-peer networking of Lambda functions is now a thing thanks to Tim Wagner (aka the father of Lambda). This is a HUGE innovation and could change the way we build serverless applications.

Migration Complete – Amazon’s Consumer Business Just Turned off its Final Oracle Database
AWS just completed a multi-year project that migrated 75 petabytes of internal data stored in nearly 7,500 Oracle databases to multiple AWS database services including Amazon DynamoDB, Amazon Aurora, Amazon Relational Database Service (RDS), and Amazon Redshift. Crazy.

Zenoss Announces Unified Multicloud Serverless Monitoring
This new product unifies the monitoring of serverless functions across the Big Three public cloud providers — Google Cloud, Amazon Web Services (AWS) and Microsoft Azure. Interesting (if you’re into the whole multi-cloud thing).

Protego Labs Named Gold Winner for Business Products Startup of the Year and Bronze Winner for Technology Software Startup of the Year by CEO World Awards
Congrats to the team over at Protego for these awards. The recognition is well-deserved.

Serverless Stories 📖

Serverless Challenges & Workarounds!
I always love hearing about people’s experiences with serverless, and this post by Manish Kumar is a quick, but enlightening read. Cold starts and connections to RDBMS continues to be the biggest challenges it seems. Luckily the VPC cold start issue is pretty much fixed, and Manish used the serverless-mysql package to fix the database issue.

Serverless: Things I wish I had known – Part 2 – DynamoDB x MongoDB x Aurora
Cleriston Bernardes has another post that lays out more snafus he ran into using serverless. I appreciate all the references in there to my blog posts, but I really feel like a lot of the challenges he faced are solvable through better content. If I only had more time. 🤷‍♂️

CRM Solutions: Building a Serverless Zoho Service
Here’s how Connor McIntyre built an integration into Zoho using AWS and Lambda.

Serverless Use Cases 🗺

Serverless Scheduler
This is an interesting approach to scheduling by Michael Bahr. He is using the DelaySeconds message attribute in SQS to control the precision of bulk loaded events into a scheduling queue. Since you can delay visibility in SQS up to 15 minutes, the bulk loading process from DynamoDB has a large window to work with. This might be more cost effective than using Step Functions to implement ad hoc schedules. Very cool idea.

Serverless Machine Learning Inference with Tika and TensorFlow
This is a great post by Oliver Mannion that outlines another ML inference use case for AWS Lambda, predicting “strong applicants” based on data extracted from resumes.

Build a personalized newsletter with AWS cloud services and ElasticSearch
This is a great use case outlined by Pierre Cavalet. A couple of Lambda functions, SQS, Elasticsearch, and a few managed services to build out your own personalized newsletter system.

Sending notifications from Amazon Aurora PostgreSQL
It would be great if PostgreSQL had Lambda triggers like the MySQL version does. Oh, and add that functionality to Aurora Serverless as well, please. 😉

Deploying Machine Learning Model to AWS Lambda using Serverless
My eyes glossed over a bit reading this, but Navarasu Muthu shows you how to deploy a machine learning model on AWS Lambda.

When you’re looking for some advanced serverless concepts… 🏗

Where Serverless plugin stops and platform starts
The amount of boilerplate code you need for your serverless application can have a big impact on your ability to manage it. It gets even more difficult if you’re trying to implement organization-wide policies and tools. Yan Cui has some recommendations about where you might want to put some of these account-level components.

Serverless Deployment Best Practices
The Serverless Framework has been adding new full-lifecycle features like crazy lately, and one you definitely should check out is safeguards. Fernando Medina Corey points out some best practices, including how to use safeguards to protect your deployments.

AWS Lambda with Static IP Address
The need for a static IP address is quite common for many use case. Balkaran Brar show you how to set that up using a NAT Gateway with your Lambda functions. You’d probably want to codify this in a CloudFormation template, but this post will help you get started.

On the Importance of Correct Headers and Metadata in S3 Origins for AWS CloudFront
Regis Wilson has an excellent post that does a deep dive into the nuances of managing headers with S3 and CloudFront. Definitely worth the read to see if you are experiencing similar issues (and need to know how to fix them).

Serverless Tutorials 🏗

Serverless TensorFlow workflow with EC2 auto-training
Awesome tutorial by Mike Moritz that walks you through setting up Lambda to do ML predictions while offloading the training to an EC2 instance.

Monitor Lambda cold start durations with CloudWatch
Yan Cui has a way for you to add monitoring of your Lambda function cold starts by using the async-custom-metrics SAR app.

Rock Solid Lambda Development with Tests and Version Control
I like Tim Hawkins enthusiasm for test-driven development, and the unit testing strategy he uses works well. But I would recommend using a framework like SAM or the Serverless Framework to deploy your functions instead of trying to roll your own.

GraphQL API using Serverless + AWS AppSync + DynamoDB + Lambda resolvers + Cognito. [Part 3]
In the third part of Facundo Fasciolo’s series on building a serverless GraphQL API, he shows you how to implement queries and mutations that use your local DynamoDB database.

Migrate Your AWS Lambda Functions to Kubernetes with OpenFaaS
Let’s say you wanted to start using Kubernetes to run your serverless workloads instead of Lambda. Here is a guide by Burton Rheutan that will walk you how to migrate them to OpenFaaS.

Deploy a Symfony application with AWS Lambda: a quick guide
I really appreciate people trying crazy things on Lambda, but I’m not sure deploying a full-fledge Symfony app would be at the top of my list. Alessandro Minoccheri gave it a go, and he got it working. So if you are thinking about migrating your existing Symfony app to serverless, this might get you going in the right direction.

Serverless Reads 🤓

Implementing Serverless Microservices Architecture on AWS
Straightforward outline of a serverless microservice architecture by Aarti Parikh. I’m a big fan of structuring your microservices this way, though I would probably split out the S3 frontend in his example.

My DynamoDB Wish List
Alex DeBrie lays out his two biggest #awswishlist items for DynamoDB. With re:Invent coming up, let’s hope he gets these granted.

Penalties and Purgatory
Subbu Allamaraju converted his talk from Serverlessconf New York into a blog post. He makes a lot of interesting points in here about time-to-value and added complexity from microservices increasing MTTR.

Recap: ServerlessDays Istanbul
If you missed ServerlessDays Istanbul, Piril Engin has a full recap of the event for you.

Tracing for Everyone: Business Flows Simplified
Thundra continues to build some amazing things into their products. This overview of their OpenTracing-compatible distributed tracing engine Otto, is a pretty cool look into what is possible.

If you prefer an audio/visual experience… 📽

Serverless Chats Podcast – Episode #18: Pushing the Limits of Lambda with Michael Hart (Part 1)
In this episode, I chat with Michael Hart about the inner workings of AWS Lambda, the hows and whys of Custom Runtimes & Layers, Docker Lambda, serverless CI and so much more! This is PART 1 of a two-part conversation.

PODCAST: The Serverless Smarts Podcast, Ft. Jeremy Daly. Stateful FaaS & the Future of IAM
I joined Hillel Solow on his podcast to discuss “serverless 2.0” trying to add statefulness to FaaS, the IAM conundrum, and lots more on the current state of serverless security in the cloud.

Fireside Chat: Petco Discusses Modernization & Their Adoption of Serverless
Ben Kehoe and Phil Potloff, talk enterprise modernization with Brendten Eickstaedt, VP Innovation Services at Petco. They discuss how Petco got started, some of the resistance they faced, how to overcome that resistance, and the benefits they’ve seen as a result. Great serverless conversation.

Demo of getting a single HTTP function deployed with using CloudFormation & Arc Demo 2
Brian Leroux started creating some videos that show you how easy the Architect Framework is. And, yes, it is very easy to use.

When you’re wondering what the AWS Devs have been working on… 👷‍♀️

Amazon Kinesis Data Firehose adds support for data stream delivery to Amazon Elasticsearch Service 7.x clusters
Amazon Kinesis Data Firehose now supports streaming data delivery to Amazon Elasticsearch Service version 7.x clusters for near real-time data analysis and visualization.

AWS CodePipeline Enables Setting Environment Variables on AWS CodeBuild Build Jobs
You can now set environment variables for CodeBuild build jobs in your pipeline. Previously, build jobs in your pipeline could only use environment variables defined in the build project configuration or buildspec file.

Amazon Kinesis Data Firehose adds cross-account delivery to Amazon Elasticsearch Service
Amazon Kinesis Data Firehose now supports delivery to Amazon Elasticsearch Service across accounts. Now your delivery stream and your Elasticsearch clusters can reside in different accounts.

Amazon Athena now provides an interface VPC endpoint
Amazon Athena now allows you to connect directly to Athena through an interface VPC endpoint in your Virtual Private Cloud (VPC). With this feature, you can submit your queries to Athena securely without requiring an Internet Gateway in your VPC.

Thoughts from Twitter 🐦

I’ll be going to @awsreinvent for the first time this year. I asked my colleagues for their top tips for first time #AWS #ReInvent attendees. Here’s what they said… ~ @helenanders26
If you’re going to re:Invent this year, take a few minutes to look through these tips. re:Invent is so overwhelming, that it’s good to keep things like this top of mind.

Upcoming Serverless Events 🗓

There are a lot of upcoming serverless events, webinars, livestreams, and more. If you have an event you’d like me to mention, please email me.

October 14-16, 2019 – Serverless Architecture Conference Berlin

October 21, 2019 – Advanced Serverless Orchestration with AWS Step Functions – Webinar

October 21, 2019 – Mocking and Testing Serverless APIs with AWS Amplify – Webinar

October 22, 2019 – How to Build Highly Scalable Serverless Applications with Amazon Aurora Serverless

October 24, 2019 –  ServerlessDays Stockholm

October 30, 2019 – Retail at the Scale of Serverless with AWS – Webinar

October 30, 2019 – Managing Serverless Applications with SAM Templates

November 6-8, 2019 – Serverless Computing London

Serverless Star of the Week ⭐️

There is a very long list of people that are doing #ServerlessGood and contributing to the Serverless community. These people deserve recognition for their efforts. So each week, I will mention someone whose recent contribution really stood out to me. I love meeting new people, so if you know someone who deserves recognition, please let me know.

This week’s star is Jared Short (@ShortJared). Jared is a Senior Cloud Engineer at Trek10, Inc., and was an early contributor to the Serverless Framework. He has been building production scale serverless applications since 2015, and has been sharing what he’s learned along the way. He’s written several great blog posts, given numerous talks, contributed to open source serverless projects, and basically lives and breathes serverless all the time now. His contributions have had a huge impact on the serverless community, and we thank you for it! 🙌

Final Thoughts 🤔

I had an absolute blast last week at Serverlessconf NYC. I got to meet up with some old friends, and I met a bunch of amazing people working with serverless. I also gave my 45 minute talk in 21 minutes, so I was a bit out of breath by the end (I think I may have blacked out somewhere in the middle as well), but it was a lot of fun. There are so many cool things happening with serverless right now, and so many great companies working with it. The next few months should be really interesting.

I also had a number of conversations about this newsletter, and more specifically, what I can do to deliver the most value to people. I got some great suggestions, and I hope to start implementing some of them very soon. Exciting times ahead. 🚀

I hope you enjoyed this issue of Off-by-none. Please send me your feedback and suggestions as they help to make this newsletter better each week. You can reach me via Twitter, LinkedIn, Facebook, or email and let me know your thoughts, criticisms, or (perhaps) even how you’d like to contribute to Off-by-none. If you like this newsletter, and think others would too, please do me the honor of sharing it with friends and coworkers who are interested in serverless.


Off-by-none: Issue #58

Live from Serverlessconf NYC… 🗽

Welcome to Issue #58 of Off-by-none. Thanks for joining us! 🙌

Last week, we made you fall in love with Step Functions and shared lots of exciting serverless news. This week, we’re live from Serverlessconf NYC, talking with some of the pioneers in serverless. Plus, we’ve got plenty of amazing content from the serverless community.

Lots to get to, so let’s jump right in! 👍

Serverless News & Product Announcements 🚀

Easily Deploy GraphQL APIs with Serverless Components
Serverless Framework Components are on a roll. The new AppSync component is fast to deploy, loaded with a bunch of sane defaults, and supports all the features you need to launch a serverless GraphQL service.

Google will not donate Knative framework ‘to any foundation for the foreseeable future’
I looks like Knative will remain in Google’s hands for the time being. I think this makes sense, as I’m sure Google has a lot of plans for serverless and wants to control (or heavily influence) the trajectory of this project.

The next chapter – faastRuby
It looks like there are some changes happening to faastRuby. It’s being moved to Shopify, which I’m not really sure what that means. But it sounds like you need to move your workloads of their servers.

TriggerMesh announces EveryBridge Serverless Event Bus
TriggerMesh EveryBridge is a cross-cloud event bus that enables event-driven cloud-native applications across multiple cloud providers and on-prem infrastructures. Serverless Inc. did something similar to this two years ago, so it’ll be interesting to see if customers find this useful.

Simplified Serverless Insights on Amazon CloudWatch
Thundra has added some improvements to their product. You can now view all your functions without instrumentation, plus, gather insights from CloudWatch Logs instead of directly from the instrumentation.

Serverless Stories 📖

Lambda@Edge and S3 Landing Page Caching for Performance and Scale
Regis Wilson from TrueCar recounts how they used Lambda@Edge to minimize page load times and increase frontend performance.

Serverless Use Cases 🗺

Build a SAM Application to Send AWS CloudWatch Notifications to a Slack Channel
Here’s a straightforward use case for notifying your team via Slack when a CloudWatch alarm goes off. Hongbo Liu shows you how to connect an alarm to an SNS topic and then push that to Slack with a Lambda function.

Counting Up to 1 Billion YouTube Views on “Sweet Child O’ Mine” for Guns N’ Roses
Could there possibly be a better use case for serverless than to track views for the Sweet Child ‘O Mine video? Not only does Slash lay down the most iconic guitar solo of all time, but I can’t believe it’s approaching a BILLION views on YouTube! 🤘🏻🎸

Serverless Geospatial
This a great read from Tomas Holderness that shows you how addresscloud is using serverless to power their business. They’re even starting to test Aurora Serverless to replace their PostgreSQL cluster.

When you want to brush up on some serverless concepts… 🏗

Using The Serverless Framework To Easily Deploy To Multiple Environments
Looking to modularize your serverless deployments? This post outlines some strategies that will let you deploy your serverless application with CI/CD to multiple environments using variables and environment specific config files.

AWS API Gateway and multiple CORS Origins
CORS tends to trip a lot of people up. Drasko Profirovic gives you some of the basics and shows you how to create headers based on some simple pattern matching.

Aurora Serverless 1O1
If you’re curious how Aurora Serverless works, this post from Piyush Jalan will give a quick run down.

Anatomy of AWS Lambda
Here is basically everything you need to know about how Lambda works. Details about invocation methods, the concurrency model, permissions and much more.

All you need to know about caching for serverless applications
Yan Cui shows you a number of ways to add caching to your serverless application. Caching can dramatically increase your serverless app’s performance, protect against hitting limits, and maybe even lower your costs.

5 Tips for getting the most out of AWS SAM
Efi Merdler-Kravitz has been building serverless apps for quite some time. Here are his five tips for building apps with AWS SAM.

Unleashed Lambdas-Outside the Handler
Derek Gau explains how to use global variables in Lambda functions to maintain state across invocations. In his example, he reuses MySQL connection pools. This works, but the problem is, he’s creating a new pool for each concurrent connection. So although he benefits from reuse, he still could run into a max_connections issue.

Serverless Tutorials 🏗

Async Callbacks with AWS Step Functions and Task Tokens
Zac Charles gives you a run down of how to use Task Tokens with AWS Step Functions to run asynchronous worker processes. He calls out a few limitations with this approach as well.

Getting Hands Dirty with AWS CDK
Thinking about getting started with the AWS CDK? This post from Asanka Nissanka shows you a practical use case.

Building A Serverless API with AWS Lambda
Anthony Plescia from shows you how to build and deploy a serverless API using ALB and a Lambda function written in Go.

GraphQL API using Serverless + AWS AppSync + DynamoDB + Lambda resolvers + Cognito. [Part 2]
Part 2 of Facundo Fasciolo’s series on building a serverless GraphQL API. This post shows you how to mount DynamoDB and run it locally.

How to build a Serverless-React contact form integrating email, Slack, MS Teams and creating tickets in Trello.
If you need a simple serverless contact form that integrates with a bunch of other notification services, check out this repo from Christian Castillejo Arcos.

Serverless Security 🔒

The API Gateway security flaw you need to pay attention to
Yan Cui points out that ALL your APIs in an entire region share a rate limit that can be exhausted by a DoS attack on a single method. He’s got some suggestions on how to protect yourself from this.

Serverless Reads 🤓

AWS billing is broken and Kubernetes won’t last, says irreverent economist Corey Quinn
This was a great interview with Corey Quinn. Not really about serverless, but worth the read. In case you didn’t know, “Larry Ellison is not people!”

The Cloud Is Transforming How We Build Software — Here is How Companies Can Prepare
If you’re having trouble convincing management to embrace serverless, have them read this article. “Cloud-Native And Serverless Are The Future. Embrace It Now.”

Serverless – a paradigm shift in app development
John Demian outlines why serverless makes you think differently, what roll third-party services play, and how it differs from traditional architectures.

Is going serverless worth it? Pros and Cons of Server-Less
I prefer a positive approach, so I try not to criticize people that write articles about serverless. However, I think this article is incredibly misleading. I included it because I believe that the author’s impression of serverless is likely a failure of our ability to properly explain it. This concerns me.

The cloud lock-in myth: opting out of servers, and opting into de facto standards
Brian LeRoux has a great new post that exposes cloud lock-in for what it truly is, a myth. The world is moving to serverless because it gets rid of the boring parts of building apps for the cloud. Brian suggests you get on board, or get left behind.

If you’ve got a long commute… 🚙

Episode #17: Building Serverless Apps Using Architect with Brian LeRoux
In this episode, I chat with Brian LeRoux about why he and his team built the Architect Framework, how it makes building modern serverless apps easier, and why DynamoDB should be your cloud database of choice.

When you’re wondering what the AWS Devs are working on… 👷‍♀️

Improving the Getting Started experience with AWS Lambda
Getting started with serverless can be daunting, but this new feature from AWS hopes to solve that problem. Now you can create an app in the console that utilizes infrastructure as code (IaC), creates a CI/CD pipeline for deployment, and bakes in best practices in serverless application structure and methods.

Amazon Translate now adds support for seven new languages – Greek, Romanian, Hungarian, Ukrainian, Vietnamese, Thai, and Urdu
As I said last time, it would be great if they’d added support for English as well! 😀

Amazon EventBridge now supports AWS CloudFormation
Yes, yes, yes, finally, yes, thank you, why did this take so long, yes, yes, yes!

Amazon Cognito Increases CloudFormation Support
Another useful update to CloudFront.

Amazon Elasticsearch Service provides option to mandate HTTPS
Not serverless, but since this is really the only service that we use in AWS that will give us good, real-time search capabilities, it’s good to see this security improvement.

Amplify CLI simplifies starting from existing Amplify projects and adds new command for extending CLI capabilities
With a single command, the update CLI clones a git repo, deploys the backend, and configures the frontend. This helps speed up the process of set up, development, and testing existing Amplify projects.

Serverless Tools 🛠

Introducing the lumigo-cli
We mentioned this tool last week, but some new features have been added and it’s definitely worth taking a look.

Thoughts from Twitter 🐦

27 features and fixes, 11 documentation updates, 16 community contributors in AWS SAM 1.15.0. With added support for APIGW resource policies, SNS <-SQS subscription, Lambda batch window size, and Cognitio event sources #serverless #awssam #nobigdeal ~ Salman Paracha
AWS SAM keeps getting better and better. There are some very cool updates here, including SNS event support for SQS Subscriptions and MaximumBatchingWindowInSeconds support for stream event sources.

I just cut a new major version of img2lambda ~ Clare Liguori
Lots of great updates to the img2lambda tool as well, which lets you repackage container images into AWS Lambda function deployment packages and Lambda layers.

Upcoming Serverless Events 🗓

There are a lot of upcoming serverless events, webinars, livestreams, and more. If you have an event you’d like me to mention, please email me.

October 7-9, 2019 – Serverlessconf 2019 in New York City

October 10, 2019 – Integration Patterns in a Serverless World Webinar

October 14-16, 2019 – Serverless Architecture Conference Berlin

October 24, 2019 –  ServerlessDays Stockholm

October 30, 2019 – Retail at the Scale of Serverless with AWS – Webinar

Serverless Star of the Week ⭐️

There is a very long list of people that are doing #ServerlessGood and contributing to the Serverless community. These people deserve recognition for their efforts. So each week, I will mention someone whose recent contribution really stood out to me. I love meeting new people, so if you know someone who deserves recognition, please let me know.

This week’s star is Eslam Hefnawy (@eahefnawy). Eslam is a Senior Core Developer on the team at Serverless, Inc. and a regular contributor on the Serverless blog. Eslam is one of the co-creators of the Serverless Framework and continues to create other great open source projects as well. He has been one of the driving forces behind the new Serverless Components, which you should definitely be keeping your eye on. Eslam brings tremendous value to the serverless space and we are thankful to have him. Thanks for all you do, Eslam! 🙌

Final Thoughts 🤔

I’ve been meeting and chatting with lots of great people here at Serverlessconf NYC. The team at A Cloud Guru has done a fantastic job bringing together all these serverless fanatics. I need to get back to the hallway track here, but I’ll leave you with this. Every conference I attend shows that the serverless space is continuing to mature and that more and more people are jumping on the bandwagon. There is a lot of exciting news to come in the next few months, so stay tuned for the next evolution of serverless.

I hope you enjoyed this issue of Off-by-none. Please send me your feedback and suggestions as they help to make this newsletter better each week. You can reach me via Twitter, LinkedIn, Facebook, or email and let me know your thoughts, criticisms, or (perhaps) even how you’d like to contribute to Off-by-none.

If you like this newsletter, and think others would too, please do me the honor of sharing it with friends and coworkers who are interested in serverless.

Until next week,

Off-by-none: Issue #57

Stepping it up with Step Functions…

Welcome to Issue #57 of Off-by-none. Thanks for joining us this week! 🙌

Last week, we watched some videos from ServerlessDays Milan and looked at some awesome new AWS serverless announcements. This week, we’ll make you fall in love with Step Functions all over again (well, maybe), we’ve got lots of exciting serverless news, and plenty of great content from the serverless community.

Lots of amazing serverless stuff to get to, so let’s get right to it. 🚦

Serverless News & Product Announcements 🚀

Announcing Gatsby’s $15M Series A Funding Round
Kyle Mathews has every right to celebrate. Gatsby is an incredibly useful tool that is completely changing the way people are building websites. It’ll be interesting to see what they can do with this new investment.

Zero Configuration Monitoring and Alerts now available for serverless Python apps
Support for Python has been added to the Serverless Framework Dashboard to enable monitoring, alerts, and much more for your Python serverless applications.

Knative v0.9.0
If you’re keeping up with Knative, Mete Atamel will let you know all the new features of the v0.9.0 release.

AWS EventBridge and Epsagon Automated Tracing Integrate
You can now get all of your Epsagon alerts and insights sent to EventBridge. This will allow you to trigger all kinds of workflows from these events.

Workers Sites: Extending the Workers platform with our own serverless building blocks
So this is pretty cool. You can now simulate a file system on top of Workers KV and easily publish static sites to the edge using Cloudflare Workers.

Not so static… Introducing the HTMLRewriter API Beta to Cloudflare Workers
And here is some more Cloudflare Workers serverless goodness.

Lumigo Achieves AWS DevOps Competency Status
Congrats to Erez and the team at Lumigo!

Stackery Launches Global Partner Program to Accelerate Well-Architected Serverless Application Delivery
The Stackery Partner Program is a global initiative to empower solution integrators with application development practices to deliver fully realized serverless applications to customers using the Amazon Web Services (AWS) Well-Architected Framework.

Auto-Tracing for AWS Lambda Calls to Redis Databases
With VPC cold starts being dramatically reduced, I think using Redis with your Lambda workloads will become more prominent. And with IOpipe’s newly added automated tracing support, you’ll have more insights into your Redis interactions.

Serverless Stories 📖

How human behaviour influences the technical approach to a platform ~
A walk-through of how Frank Digital redesigned cancer support services using serverless technology.

An Upgrade: Part 1
Guillermo Fisher is working to upgrade his personal website by continuing to build on his already serverless implementation. He documents his thought process in the first post in this series, and it is a really interesting read.

How I Future-Proofed My Tech Stack
This is worthwhile read from Albert Santalo from 8base. The comments are quite interesting as well. I’ve always advised startups to “not worry about scale” because it often wastes a lot of engineering time that could be better spent on finding product-market fit. But I think that calculus changes when companies adopt serverless.

Serverless Use Cases 🗺

Serverless Mullet Architectures
Tim Wagner, aka the father of AWS Lambda, has an interesting use case using API Gateway WebSockets to coordinate “server-to-server” communication backed by AWS Lambda and DynamoDB.

Using DynamoDB to track changes to DynamoDB
This is an intriguing use case from Dan Moore that uses DynamoDB streams to automatically calculate diffs and write them to another DynamoDB table as an audit log. He deploys it straight from the aws-cli, but I’d recommend using a framework to handle all this for you.

How to create a customized CloudWatch Dashboard with CloudFormation
Here’s a great use case for serverless: build a custom CloudFormation resource using a Lambda function. Andreas Wittig will walk you through how to do it, and show you how to create a customized CloudWatch Dashboard with it.

Running transient servers with serverless
Martin Raag has a good use case for serverless, spinning up and configuring EC2 instances to perform long-running tasks. There are plenty of workloads that still require more traditional solutions, and using Lambda functions to help automate tasks is a great way to get started.

Advanced Serverless Concepts… 🏗

Best Practices for AWS Step Functions
Rowan Udell lays out a bunch of best practices for working with AWS Step Functions. My favorite one is letting Lambda functions fail and bubble up to the state machine. It’s a good way to keep your business logic untethered from the implementation.

SNS, SQS or both?
This is an overview of SNS (Simple Notification Service), SQS (Simple Queue Service) and how they can be used in isolation or together to send persistent and immediate messages.

Serverless: Things I wish I had known before I started – Part 1 – AWS Cognito
Cleriston Bernardes has another interesting post, this time focusing on some of the limitations he’s found with AWS Cognito. Worth looking at if you are considering using this service.

6 strategies for scaling your serverless applications
Preston Holmes from Google explains how Google Cloud Functions scale, and what are some considerations when downstream services might not handle serverless scale. If you’re using Google Cloud for serverless, take a look at the recommendations in this post.

Should you pack the AWS SDK in your deployment artefact?
Yan Cui answers this question for you. If I were you, I’d take his advice. 😉

Lambda Functions Are NOT Fault-Tolerant by Default
This piece by Renato Byrro explains a little bit about Lambda’s retry behavior and why you need to make sure your operations are idempotent.

AWS Developer Tools: Your Ally in Deploying and Maintaining Your Serverless World on AWS
Serkan Özal gives an overview of the most popular tools for building automated test and deployment pipelines with AWS.

Top 10 Serverless best practices
Yan Cui has some more advice for you. If you’re using the Serverless Framework, here are 10 things you should consider doing.

Distributed Tracing
Ran Ribenzaft has a great article that goes into the details of what distributed tracing is, and how you might go about implementing it in your applications. Long story short, use an observability tool that provides distributed tracing out of the box.

If you’re just getting started with serverless… 🐣

Configuring Serverless Framework to work with AWS Lambda
Omal Vindula gives you a quick start guide to downloading and configuring the Serverless Framework.

3 Major Challenges of the Serverless Framework, and How to Overcome Them
Here are some simple tips from Hugo Burbelo that will get you started with the Serverless Framework.

First steps with serverless Python: write to s3 and call other Lambdas
Toby Fee thinks Python isn’t getting enough attention, so here are two simple Python examples that you can use to build a Lambda function.

Serverless Migration: Lift-and-shift
Ryan Jones has another post in his series on Serverless Migration. This time he looks at taking an existing and app and trying to port it to a cloud function. There are some reasons why this likely won’t work, which Ryan explains.

Serverless Migration: Choosing a deployment framework
In his second Serverless Migration post this week, Ryan Jones outlines several serverless deployment frameworks and what they are best suited for.

Serverless Tutorials 🏗

GraphQL API using Serverless + AWS AppSync + DynamoDB + Lambda resolvers + Cognito. [Part 1]
Facundo Fasciolo is working on a multipart tutorial for building a serverless GraphQL API. In part 1, he outlines the “Serverless basic configuration” to get your app setup and working locally with mock data.

Localizing applications with Cloudflare Workers’ new streaming HTML Rewriter ?
We mentioned Cloudflare Workers’ new HTMLRewriter earlier. Here’s a use case and tutorial for it that lets you localize the text on your site based on the user’s geographical location. While this use case might be trivial, there are plenty of other things you can do with it. And… it’s a lot easier that some other cloud provider’s implementations.

Full Stack AWS Application Development (Free Course)
Gareth McCumskey and Serverless, Inc. have a new (free) course on developing serverless applications on AWS with the Serverless Framework. It’s not complete yet, but this should be a great resource to follow along with.

Serverless Security 🔒

PCI DSS and Serverless Demystified
Everything you ever wanted to know about PCI DSS and serverless.

Serverless Reads 🤓

How Red Hat is pioneering a serverless movement
William Markito Oliveria talks about Red Hat’s serverless vision and where they see the future of serverless going. And, surprise, they’re going all in on Kubernetes.

Why #Serverless Is Eating the Stack
Renato Byrro outlines a number of reasons why serverless is becoming the “go to” choice for lots of companies. The reasons he outlines are not new, but everyday we seem to get more and more evidence to support them.

Serverless Data: The Winning Cloud Adoption Strategy
This is a great piece by Venkat Venkataramani that makes the bold claim that “Open Source Software on Cloud Hardware is the New Legacy”, which I totally agree with. Managed service (including managed open source services) take the operational responsibility off your team, and moves it to a dedicated team of cloud professionals, at a fraction of the cost of hiring your own people.

Testing improvements to Lambda VPC Networking
Matt Lewis did some quick tests of the new Lambda VPC networking improvements and the results are amazing!

Why I pick Heroku over AWS Lambda. But not always.
Tim Nolet has a well-written piece on when and why he might choose Heroku over AWS Lambda. There are some good points in here about vendor lock-in, and why it’s probably not something you need to worry about.

AWS Serverless Building Blocks for Microservices
I like reading how other people think about serverless microservices. Ashan Fernando outlines a few ways to use serverless “middleware” to handle service-to-service communication.

The Hidden Problem of Serverless
Toby Fee compares managing serverless applications to the responsibility of taking care of pet birds. I think the comparison is quite apt. 🐦

While you’re waiting for season 4 of Stranger Things… 📽

Episode #16: Serverless Workflows using Step Functions with Rowan Udell
In this episode, I chat with Rowan Udell about the benefits of state machines, the core functionality and advanced features of AWS Step Functions, and some recommendations for building smarter serverless workflows.

Serverless Azure Fundamentals
Part 5 of Jeremy Likness’ Moving from Lambda to Azure Functions (5 Part Series).

How to use AWS Cloud9 (and AWS SAM) to create serverless projects | SAM Series #2
This video shows you how to use the Cloud9 IDE to create, deploy and debug serverless projects using the AWS SAM framework.

API Gateway security mechanisms | Serverless Security
In this video, Marcia Villalba shows us different mechanisms that API Gateway has built-in for providing security for your serverless applications.

Serverless Transformation: An Online Panel Discussion
Ben Ellerby hosts panelists Nader Dabit, Emrah Samdan and Craig Mayhew to discuss a range of serverless topics.

When you’re wondering what the AWS Devs are working on… 👷‍♀️

Not much to announce on the serverless side of things this week, but I’m sure we’ll be seeing a lot more coming soon.

DynamoDBMapper now supports optimistic locking for Amazon DynamoDB transactional API calls
If you’re using Java and DynamoDB, this new update to DynamoDBMapper should make your transactional API calls more reliable.

Serverless Tools 🛠

Who’s the Faastest?
Nuweba launched this cool little tool that shows you which FaaS services and runtimes are the “faastest”.

Edit serverless YAML templates in VSCode like a pro
Pavel Vlasov created an extension for VSCode that does autocompletion and implements some other fancy features when working with AWS SAM, CloudFormation, and serverless.yml files.

How To Work with AWS Lambda in Swift
If you are a Swift developer and want to build Lambda functions using Swift, check out this new custom runtime by Andrea Scuderi.

Thoughts from Twitter 🐦

One of the biggest engineering costs you can reduce is developer-thumb-twiddling. Brought our frontend CI time down from 8 mins to 25 secs by parallelizing on AWS Lambda ( @lamb_ci ). Each Lambda tests every nth file (testing/formatting/linting 3k files over 13 sites). ~ Michael Hart
Using Lambda functions to parallelize tasks (with isolation between them) makes for some pretty fascinating use cases. Michael Hart uses them to run all his CI checks for lambCI, and the increase in speed is incredible.

Upcoming Serverless Events 🗓

There are a lot of upcoming serverless events, webinars, livestreams, and more. If you have an event you’d like me to mention, please email me.

October 2, 2019 – Deep Dive on Amazon EventBridge (Webinar)

October 3, 2019 – How to Leverage Serverless to Optimize for Cost and Performance (Webinar)

October 7-9, 2019 – Serverlessconf 2019 in New York City

October 14-16, 2019 – Serverless Architecture Conference Berlin

October 24, 2019 –  ServerlessDays Stockholm

October 30, 2019 – Retail at the Scale of Serverless with AWS – Webinar

Serverless Star of the Week ⭐️

There is a very long list of people that are doing #ServerlessGood and contributing to the Serverless community. These people deserve recognition for their efforts. So each week, I will mention someone whose recent contribution really stood out to me. I love meeting new people, so if you know someone who deserves recognition, please let me know.

This week’s star is Sam Kroonenburg (@samkroon).  Sam is the CEO and co-founder of A Cloud Guru, an online learning platform that has helped almost a million people learn cloud computing (and pass AWS Certification exams). Sam is a huge fan of serverless and a regular speaker on the subject. Most of the content that creates is available with a subscription, but their blog also has a ton of great community content for free. Sam and his brother, Ryan, also started Serverlessconf, and the 9th edition of it is happening next week in NYC. These events always produce great talks that help people think differently about serverless and continue to drive the ecosystem forward. Thanks for all the work you do for the community, Sam! 🙌

Final Thoughts 🤔

It was another busy week for me as I continue to work on a new serverless project. There have been a lot of learnings from it, so I hope to be able to write about them and share it with you all soon. I just need to find the time! 😬

I’ll be at Serverlessconf next week, so I hope to see some of you there. I’ve got plenty of stickers for Off-by-none and Serverless Chats, so please come and say “Hi!”

I hope you enjoyed this issue of Off-by-none. Please send me your feedback and suggestions as they help to make this newsletter better each week. You can reach me via Twitter, LinkedIn, Facebook, or email and let me know your thoughts, criticisms, or (perhaps) even how you’d like to contribute to Off-by-none.

If you like this newsletter, and think others would too, please do me the honor of sharing it with friends and coworkers who are interested in serverless.


Off-by-none: Issue #56

Custom Batch Windows, Dynamic Parallelism, and the PostgreSQL Data API… 😱

Welcome to Issue #56 of Off-by-none. Thanks for joining us! 👋

Last week, we look at a new way to model our DynamoDB data and shared lots of exciting serverless news. This week, we’ve got videos from ServerlessDays Milan, some awesome new AWS serverless announcements, and a ton of content from the serverless community.

Plenty of great stuff to get to, so let’s jump in. 👍

When you try to say “serverless” in Italian… 🇮🇹

Back in June, I gave the opening keynote at ServerlessDays Milan. They just posted the video of my talk, so if you’d like to listen to me tell people to “Stop Calling Everything Serverless”, you should give it a watch. There were some really amazing talks that day. Here are some of my favorites that you should definitely check out:

All of the talks were really great. You can check out the rest of them here.

Serverless News & Product Announcements 🚀

There were several really great announcements from AWS this week, so be sure to check out the AWS updates section below.

Iguazio Expands Serverless To Scale-out Machine Learning and Analytics Workloads
New serverless capabilities in Iguazio’s Data Science Platform enable on-demand resource consumption, elastic scaling, and simpler ML pipelines.

Serverless Stories 📖

Flexy: Serverless Travel App
Kelvan Ince built a new app that has a completely serverless backend. Check out how he built it.

Serverless: 15% slower and 8x more expensive
This enlightening post by Einar Egilsson exposes the major problems that serverless advocates face. There are so many ways to accomplish things with serverless, and it’s fairly easy to rack up huge expenses and run into bottlenecks if you design your application incorrectly. Chris Munns had a thoughtful response to this, which you can read here.

How I Built a Serverless BigCommerce App on AWS
If you’ve got A LOT of free time and want to read all about how Patrick Puente built a serverless app on AWS, check out this article.

Serverless Use Cases 🗺

Adobe Campaign Content Recommendations in Email
I really like the idea of vendor-side serverless compute models like Adobe I/O and Twilio functions. In this post, Denis Bozonnet uses an Adobe I/O function to add personalized content recommendations to user emails. This is certainly possible using APIs and transactional emails with third-party systems, but why not just simplify the entire process and run it at the source?

Playing with Cloudflare Workers
I love these little use case for serverless. Antal Orcsik uses a Cloudflare worker to transform a URL and perform a redirect, in 8 lines of code. Simple, straightforward, and no need to set up a server.

Visual Game Worlds, designed in Unity, hosted in Functions-as-a-Service
Here’s an interesting use case from Tom Larkworthy. Run graphical game engines using FaaS.

When you’re interested in advanced Serverless concepts… 🏗

Building Lambda Functions with MongoDB Atlas via VPC Peering
Saras Arya explains probably more than you want to know about how VPC peering works with AWS.

Hey CDK, how can I migrate my existing CloudFormation templates?
If you’re thinking about migrating your apps to use the new AWS CDK, Philipp Garbe has a few tips to help make the transition easier.

3 methods for microservice communication
Kyle Galbraith outlines three methods that allow microservices to communicate with each other. He uses SNS as a message broker (which I used to use as well), but now with EventBridge, we have a lot more capabilities.

Gently Down the Stream with AWS Kinesis
Helen Anderson’s post is an overview of how AWS Kinesis can be built into new or existing architecture to process, transform, and analyze streaming data for faster decision making.

Explaining Eventbridge Amidst the Hype
Sarjeel Yusuf explains what’s different about EventBridge, and why it could become an important part of your serverless toolkit. I’ve been using it extensively for my latest project, and so far, I’m extremely impressed.

AWS Lambda vs EC2
Rajesh Bhojwani gives us an in-depth comparison of AWS Lambda and EC2. Of course, comparing the cost of ONE t2.micro to that of a Lambda function is apples to oranges. As Rajesh points on, there’s not only the added Ops work, but additional infrastructure to support it.

If you’re relatively new to serverless… 🐣

Why Serverless Architectures?
Mohit Gupta gives an overview of why you’d want to go serverless. Plus an explanation of the serverless model, and how to get started with AWS and Lambda.

Serverless Migration: review your existing application
Ryan Jones and the team at Serverless Guru launched a series on migrating your application to serverless. This first post helps you review your existing application in order to make some decisions about the services and models you’ll be using as part of the migration.

Serverless Migration: break apart your application
In the second installment of the Serverless Migration series, Ryan Jones takes you through some use case that might apply to your application, and how you can make those use cases compatible with serverless.

Serverless: Learn how to get it into your team without making them AWS Cloud Architect Experts.
You don’t need to be a “cloud architect expert” to build a serverless application, but knowledge of the cloud and the services available is definitely a prerequisite. Cleriston Bernardes has some thoughts on how you can start building in serverless, even if you’re just starting your cloud journey.

A Serverless Function Example: Why & How to Get Started
Francis Cote has a comprehensive post that is both an introduction to serverless, as well as a tutorial for the first time user. Worth taking a look if you’re new to this whole “serverless” thing.

How to solve the testing challenges that come with serverless apps
Glenn Buckholz outlines some of the challenges you face when testing serverless applications. He offers some ideas to make it easier, and gives you an overview of some of the tools that are there to help you.

Serverless for Frontend Developers – ArmadaJS
Alexander Simovic’s presentation from ArmadaJS is a great intro for frontend developers that want to start using serverless to build full-stack applications.

Getting started with AWS SAM | SAM Series #1
Sometimes we just a need a simple introduction to something. If you are still curious what SAM (Serverless Application Model) is all about, and how to get started simply, check out this video.

Serverless – AWS Parameter Store
I hope you’re not still hardcoding secrets into your serverless functions, but if you need a basic intro to the AWS Parameter Store, Dorian Machado has you covered.

12 Reasons to Opt for Serverless Computing for Your Mid-sized Venture
This post is targeted at “mid-sized ventures”, but I think the 12 reasons outlined are applicable to organizations of every size.

Serverless Tutorials 🏗

Tutorial: Building & Monitoring Serverless Web Applications
Ran Ribenzaft has another great tutorial that shows you how to build a simple serverless web application that uses Cognito for authorization.

Deploy a static website with AWS
Need to get a static website up on AWS without all the added complexity? Karen Sanchez has a simple tutorial that walks you through the process using the AWS Console.

AWS [Amplify, Appsync, GraphQL]
Rigoberto Miranda has a full tutorial that shows you how to create and test a GraphQL API for an iOS application using AWS services AppSync and Amplify.

Deploy a Python serverless function on ZEIT Now
ZEIT is another popular way to easily deploy serverless applications. Juan Olvera’s tutorial will show you how to get up and running with a simple API.

How to get started with AWS AI Services
Timo Böhm has a step-by-step walkthrough that builds out a serverless service using Amazon Rekognition for image processing.

Testing infrastructure with the AWS Cloud Development Kit (CDK)
Imagine if you could easily write unit tests for your Infrastructure as Code configuration files? With the AWS CDK you can, and this post will show you how to do it using the familiar Jest framework.

Build Serverless REST API on AWS from Scratch – Part 1 & Part 2
This straightforward, two-part tutorial by James Murithi will walk you through creating a simple TODO API using AWS serverless, NodeJS and DynamoDB.

Serverless Security 🔒

They can’t hack your servers if you don’t have any servers, right?
Matthew Henderson has some thoughts on serverless security. As he points out, bad coding practices can create vulnerabilities in your application security, so make sure you use the tools available and add some security remediation to your DevOps pipelines.

6 Things You’re Probably Doing Wrong Securing Serverless Apps
Tal Melamed dives into six important security considerations for your serverless applications.

Serverless Reads 🤓

How We Design Features for Wrangler, the Cloudflare Workers CLI
This is a really interesting post by Ashley Lewis and Gabbi Fisher that shows how they iterated through adding functionality into the Cloudflare Workers CLI, Wrangler. It’s an incredibly thoughtful approach that product people should be adopting to build new tools.

Will AWS CDK replace Terraform and Serverless Framework?
Kevin van Ingen worked with the AWS CDK, Terraform and the Serverless Framework all in the same month, and shares some of his insights as to the strengths and weaknesses of each. He thinks the CDK has promise, but he points out that with complex projects, there is no clear winner (for now).

Monitor Your Serverless Apps Like a Formula 1 Engineer
The Serverless Guru reviews a few serverless monitoring tools and why they are an important part of your serverless application.

8 ways to speed up serverless development
Efi Merdler-Kravitz gives you some tips and tricks that will allow you to accelerate serverless development and launch your products faster.

Cloud Native is Serverless-First
John Gilbert recommends a “serverless-first” approach for several reasons, but I think the most compelling one is speed to market. Getting something out there fast and iterating on it gives startups and product dev teams a huge advantage by being able to fail faster. Containers might not be the wrong choice, but you can always fallback onto containers. Rearchitecting your app for serverless becomes a lot harder if you don’t start there.

Cloud Native is Event-First
John Gilbert has another post that reiterates the point that highly coupled systems (i.e. api-first architectures) are at a much higher risk for failure when interdependent services fail (which they will). Taking an event-first approach, systems remain autonomous, storing only the data they need, and publishing state changes via events. Does this make things more complex? Compared to a monolith, yes. But there are many benefits to this that John points out.

Do Oracle’s Claims Versus AWS Pass Scrutiny?
Oh Larry Ellison, what silly things do you have to say now? My favorite is the idea that a single Oracle database can handle EVERY possible use case. 🤦🏻‍♂️

Static First: Pre-Generated JAMstack Sites with Serverless Rendering as a Fallback
Phil Hawksworth has an excellent post that talks about “static-first” as an approach to serving up user generated content. If the static page doesn’t exist, a simple fallback to a serverless function will create the page on the fly. This is not only incredibly effective and scalable, but also incredibly inexpensive.

Compare and Contrast: VM, Containers, & Serverless
This is a great post that compares these three approaches. I agree with Shaira Yvonne’s thought at the end: “When we use serverless… then we’ll have more time listening to our customers and mainly focus on delivering what is valuable to them.”

What is Serverless?
Matthew Tyson has some thoughts about serverless and how it compares with IaaS and PaaS.

When you prefer an audio/visual experience… 🎧

Episode #15: How Liberty Mutual is Embracing Serverless with Gillian Armstrong and Mark McCann
In this episode I chat with Gillian Armstrong and Mark McCann about Liberty Mutual’s strategy for serverless adoption, how they evangelized serverless and focused on developer enablement, and some of the successful serverless projects they’ve launched.

Going Serverless with AJ Stuyvenberg
Corey and AJ discuss what a day in the life of an engineer at Serverless looks like, what the Serverless framework actually is and how it helps developers, how an open source company makes money, how Serverless differentiated itself from AWS, the differences between Serverless plugins and components, what’s in the company’s future, and more.

Nested Applications with SAR using SAM and Severless Framework | FooBar
Marcia Villalba shows you how to nest applications from the serverless application repository into your AWS SAM and Serverless Framework projects.

Publish Serverless Applications to the Serverless Application Repository | FooBar
In this video, Marcia Villalba shows you how to publish an existing SAM application to the Serverless Application Repository.

iRobot is Enabling the Next Generation of Connected Homes with a Serverless Architecture on AWS
Here’s a short video that shows Ben Kehoe and his team explaining why iRobot chose serverless on AWS and how it’s helping them make better connected products for your smart home. There are a few Richard Boyd cameos in there as well. 😉

When the AWS devs have been crushing it lately… 👷‍♀️

Amazon Aurora Serverless PostgreSQL Now Supports Data API
The Data API keeps getting better and better, and now you can access your Aurora Serverless PostgreSQL databases as well. Make sure you check out the Data API Client for NodeJS if you want to make your life even easier.

AWS Lambda Now Supports Custom Batch Window for Kinesis and DynamoDB Event Sources
So here is another amazing update! There are a lot of use cases that include lower volume Kinesis streams or infrequently updated DynamoDB tables. Being able to control the invocation of your downstream Lambda functions based on time, record count, or payload size is a huge win for cost optimization.

AWS Step Functions adds support for dynamic parallelism in workflows
And another incredibly cool feature that has been added to your arsenal of serverless weapons. This new feature for Step Functions lets you create nested workflows that can run in parallel based on a map generated from the previous step. This gives you a lot of control over parallel processing, plus all the error handling that comes along with it. Read more in Danilo Poccia’s post here.

Amazon S3 introduces Same-Region Replication
It’s always a good idea to copy important data, and now you can use SRR (same-region replication) to automatically copy files uploaded to S3 based on the bucket, prefix, or object tag levels.

Amazon Athena adds support for inserting data into a table using the results of a SELECT query or using a provided set of values
This is incredibly cool! You can now insert data into Amazon Athena (including from SELECT query results) which will write data back to S3 for you. I can see a lot of use cases emerging from this.

Build, test, and deploy your Amazon Sagemaker inference models to AWS Lambda
This is kind of interesting. In certain situations (definitely not all) you can use AWS Lambda functions to host your Amazon Sagemaker inference models.

AWS Amplify Console provides downloadable access logs for hosted web apps
Amplify Console now allows users to download access logs for their CDN distribution. Cool.

Serverless Tools 🛠

Yan Cui and the team at Lumigo took some common serverless development tasks and shortcuts and added them to a CLI tool. I have a feeling that the features of this will continue to expand.

Chris Noring open-sourced a workshop that teaches you all about building serverless microservices using GraphQL.

Thoughts from Twitter 🐦

Ruthless definition of #Serverless found in a comment on Reddit: ‘It’s just marketing speak for “we reinvented cgi-bin, but now you pay each time it’s invoked.”‘ ~ Arialdo Martini
I know some people think this is somehow making fun of serverless, but I love thinking about FaaS this way. As someone who spent a lot of time working with cgi-bins, I welcome the analogy, because it’s just as easy, and it scales with almost no limits.

This is a good post by @einaregilsson comparing an Elastic Beanstalk workload to a Lambda + API-GW #Serverless one. Not quite apples to apples, but the math checks out. It’s important for folks to evaluate their needs across the spectrum of compute services @awscloud has (a thread) ~ Chris Munns
In addition to his post on Reddit, I have to commend Chris Munns for the way he responded to this article. “Serverless” still has a long way to go, and this was a genuine response that truly acknowledged the customer’s pain and the work that needs to be done to better educate them.

Upcoming Serverless Events 🗓

There are a lot of upcoming serverless events, webinars, livestreams, and more. If you have an event you’d like me to mention, please email me.

September 26, 2019 – Increasing Serverless Development Velocity (Webinar)

October 2, 2019 – Deep Dive on Amazon EventBridge (Webinar)

October 3, 2019 – How to Leverage Serverless to Optimize for Cost and Performance (Webinar)

October 7-9, 2019 – Serverlessconf 2019 in New York City

October 14-16, 2019 – Serverless Architecture Conference Berlin

October 24, 2019 –  ServerlessDays Stockholm

October 30, 2019 – Retail at the Scale of Serverless with AWS – Webinar

Serverless Star of the Week ⭐️

There is a very long list of people that are doing #ServerlessGood and contributing to the Serverless community. These people deserve recognition for their efforts. So each week, I will mention someone whose recent contribution really stood out to me. I love meeting new people, so if you know someone who deserves recognition, please let me know.

This week’s star is Ryan Jones (@ryanjonesirl). Ryan is the founder and CEO at Serverless Guru, a software development and consulting firm that builds modern applications using serverless. The mission of Serverless Guru is to educate companies and developers by creating content and training materials that help them succeed with serverless. Ryan’s company’s recent development partnership with Serverless, Inc., his speaking engagements, and the constant flow of content he produces, shows his deep commitment to the serverless community. We’re glad you’re here, and appreciate what you do.  🙌

Final Thoughts 🤔

Sometimes you don’t need to launch a major new product to have a huge impact on the serverless ecosystem. AWS made four relatively small improvements to existing services this week (custom batch windows, dynamic parallelism in Step Functions, PostgreSQL support for Data API, and Athena INSERTS), but all of them open up more use cases and make working with serverless even better. Are we close to the point with serverless where small, incremental improvements to existing products will be the focus, or are there still some major announcements to come? Either way, it’s an exciting time for serverless, and I’m happy to be on this ride.

I hope you enjoyed this issue of Off-by-none. Please send me your feedback and suggestions as they help to make this newsletter better each week. You can reach me via Twitter, LinkedIn, Facebook, or email and let me know your thoughts, criticisms, or (perhaps) even how you’d like to contribute to Off-by-none.

If you like this newsletter, and think others would too, please do me the honor of sharing it with friends and coworkers who are interested in serverless.


Off-by-none: Issue #55

A better way to model DynamoDB? 🤓

Welcome to Issue #55 of Off-by-none. Thanks for being here! 👋

Last week, we reviewed some very encouraging news about cold starts in Lambda. This week, we look at a new way to model our DynamoDB data, share lots of exciting serverless news, and of course, we have lots of amazing content from the serverless community.

Lots to get to, so let’s get right to it. 👍

Serverless News & Product Announcements 🚀

Stackery Appoints Tim Zonca as Chief Executive Officer
I really love what Stackery is doing. If their new CEO can help accelerate them into the enterprise marketplace, I think this will make a huge impact on serverless adoption.

Optimizely Announces Performance Edge, Enabling the Industry’s Fastest Web Experiments
This is super interesting. Optimizely (the company that lets you easily run A/B tests) has launched a new service that runs at the edge using CloudFlare workers. Multivariate testing has long been a use case for edge computing, but seeing it productized is a big step forward.

Anthos simplifies application modernization with managed service mesh and serverless for your hybrid cloud
I’m really not sure what Google’s calculation is with Anthos, but they seem to be pushing full steam ahead on giving people alternatives to using their cloud platform. 🤷‍♂️

Zenoss Launches Serverless Monitoring for Google Cloud Environments
Zenoss (remember them) is now offering monitoring for Google Cloud’s suite of serverless compute options.

Monitor and debug all serverless errors
The Serverless Framework continues to get better. This time introducing the context.captureError(error) method to capture errors without needing to fail an entire Lambda function. While failing a function makes sense sometimes, user facing functions often require a custom error to be returned. This is a great way to get the error information you need, without affecting the user experience.

How to use Serverless and Twilio to automate your communication channels
The Serverless Framework is killing it lately. Now you can deploy Twilio functions as well. I’ve said before that SaaS providers providing native code execution environments could open up a lot of use case. Now it’s super easy with the Serverless Framework.

LambdaSharp 0.7 “Geminus” is out!
This release focuses on ease of use, sharing modules, and seamless upgrading. Great tool for building serverless C# Lambda functions on AWS with CloudFormation.

IOpipe Named a Cool Vendor in Performance Analysis by Gartner
Good to see vendors in the serverless space getting recognized for the great work they are doing. Congrats to IOpipe!

Lambda@Edge support now available
This is another awesome update to the Serverless Framework. There are still some quirks with deploying and removing Lambda@Edge functions, but this added support certainly makes it easier.

Announcing the RabbitMQ extension for Azure Functions
I’ve had less-than-fantastic experiences with RabbitMQ, but I know many people that have had better luck. I do think this is an interesting way to migrate existing workloads to serverless by tapping into your app’s RabbitMQ channels. Any time you make it easier to adopt serverless, I’m all for it.

Serverless Stories 📖

Use Serverless AWS step functions to reduce VPC costs
Kevin van Ingen has a great piece that explains how his team was able to cut costs dramatically by removing their NAT Gateway and parallelizing their Lambdas with Step Functions.

Serverless Web Application – Example Architecture
Ahmed Mansour gives us some insight into how he build a recent serverless project.

Serverless Use Cases 🗺

Doing Rollups of AWS S3 Server Access Logs
Here’s a useful use case from Douglas Muth. Use a Lambda function to roll up S3 access log files. He even wrote an app for you.

Generate AWS STS credentials: The portable way
There are some security considerations with this approach, but using Lambda to quickly generate STS credentials for teams is another interesting use case.

When you want to learn some advanced Serverless concepts… 🏗

Serverless Cost Containment
Rowan Udell has a great piece that outlines some of the cost traps that serverless developers can get caught in. Many of these are easily mitigated, but the first step is knowing that they exist.

Distributed Tracing: Manual Vs. Automatic
Nitzan Shapira presents two different approaches to implementing a distributed tracing solution: Manual and Automatic. Automatic has its drawbacks, especially around flexibility. But personally, I’d rather choose a tool that gets me 80% there without needing to do any extra heavy lifting.

Taking Serverless to the Next Level
Danilo Poccia is always taking serverless to the next level. In this presentation he covers everything from IaaC to automating deployments to event-driven microservices. There are a lot of slides here, but definitely worth taking a look to understand these fundamentals.

12 New Features of AWS Amplify
AWS Amplify is on the development bullet train. The project is moving fast and releasing new features constantly. Nader Dabit outlines 12 new features that have been released over the last few months.

Invoking one Lambda function inside another (Sync-Async)
Mahfuzul Alam outlines a way to do function composition by making asynchronous calls to downstream Lambda functions. Under the right circumstances, this can work well, but be careful about synchronous invocations, especially attached to a synchronous request from a client. It might be necessary, but this creates a lot of coupling. There are generally better ways to achieve this.

The best reason to use DynamoDB streams is…
Yan Cui points out the fact that using DynamoDB streams eliminates the need to update the state of two separate systems (DynamoDB and Kinesis), which eliminates the need for distributed transactions. IMO, this model works really well within a microservice, but if you are generating events for use across service boundaries, I think the distributed transactions are worth the added complexity.

Why you should use temporary stacks when you do serverless
Yan also explains two ways that you could use temporary CloudFormation stacks when doing serverless and why you would want to. Feature branches and integration tests are the highlights here, and while there are always pros and cons, it is definitely something you should consider.

If you’re just getting into serverless… 🐣

What’s the friction with Serverless?
This is a great post for teams thinking about going serverless or for teams that have started but are hitting a brick wall. While serverless promises “writing just your business” logic, there is a lot more to it, especially having knowledge of the other managed services available to you. This shouldn’t discourage you, but it’s important to know what you’re up against.

What Front-End Developers Need to Know about Serverless Databases
Dan O’Donnell gives you some of the pros of working with “serverless” databases.

Serverless Computing and the Trend to Asset Lean
While this analogy is not new, I like how Aater Suleman compares Uber to serverless by describing the parallels between each phase in the evolution of car ownership to hailing a driver from a ride-share app.

Serverless Tutorials 🏗

How to include SNS and Kinesis in your e2e tests
SNS and Kinesis are common components in our event-driven serverless applications. However, testing them can be a bit tricky. Yan Cui walks you through some ways to accomplish this.

Building an Event-driven Pipeline in AWS Using Serverless
Kyle Galbraith shows you how to build an event-driven pipeline using S3 and Lambda. It’s also a good intro to event-driven architecture.

Shifting Your Node Express APIs to Serverless
John Papa’s incredibly thorough tutorial on converting your existing Express apps over to Azure Functions.

GO AWS Development with Serverless Application Model-SAM to start functions locally
Yunus Kılıç’s third article on building and deploying serverless functions with SAM and GO.

How to test a serverless API using AWS serverless Gradle test runner
If I’ve said it once, I’ve said it a million times (I think I said this last week too), I’ve never seen two deployment pipelines that look the same. This example focuses more on the API testing side of things, but as you will see, they have their own unique process.

.NET Core serverless CI/CD on AWS using CodePipeline and CloudFormation
Kaveh Azad gives you a complete CI/CD solution for .NET Core apps using AWS CodePipeline. The CloudFormation template is included, so you could adapt this for other runtimes as well.

How to build HTTP REST APIs with AWS + Serverless Framework
Here is a simple tutorial (in Java) for how to build and deploy a serverless API.

Part 2: How Far Out is AWS Fargate?
Go with Lambda when you can, but if you need containers, Fargate is a much simpler alternative to the likes of Kubernetes for container orchestration and management. Michael Lavers shows you how to deploy a simple Flask app to demonstrate how easy it is to get started with Fargate.

How to Create a REST API with Azure Functions and the Serverless Framework – Part 1
The Serverless Framework has made some significant improvements to the serverless-azure-functions plugin, so building on Azure is even simpler. Check out this tutorial to see how you can use the framework to build your first REST API using Azure Functions.

Serverless Security 🔒

Automating AWS Guard Duty Enrollment
Dane Fetterman wrote a tool to help you enroll a member account in AWS Guard Duty on a master account. The scripts run as Lambda functions, kicked off by a Step Function that lives behind API Gateway.

Simple Voice-Command SQL Injection Hack into Alexa Application
And here I thought ordering 100 rolls of toilet paper from your friend’s Alexa was a vulnerability. I think this is an interesting attack vector, though it likely requires some pretty bad coding on the backend. Ultimately, voice-enabled devices translate your commands into text to be processed. Taking the same precautions as you normally would should be more than enough to mitigate this kind of vulnerability.

A Purple-Team View of Serverless and GraphQL
Abhay Bhargav has a presentation on serverless security and how you probably want to manage your own serverless GraphQL endpoints (instead of using frameworks). There are other solutions out there for serverless GraphQL (namely AWS AppSync), but this presentation does outline a number of risks to be aware of.

How Are Serverless Applications Attacked?
Serverless is, by default, a lot more secure than traditional infrastructures, or even self-managed cloud architectures. However, it bears repeating that the vast majority of vulnerabilities now fall on the quality of the application code. Having a good system in place to provide AppSec in the serverless world is probably insurance worth having.

Serverless Reads 🤓

Loud Narrative on Cloud Native
I love a good rant. Raman Sharma has some thoughts (and criticisms) on some common definitions of “Cloud Native”.

Applying Code-Splitting to AWS Lambda
Running experiments to find new and interesting ways to optimize serverless is a hobby of mine too. Matt Tyler played around with code-splitting in Lambda, and although I don’t think this would create a worthwhile optimization, the idea was definitely worth pursuing.

Review: Amazon Aurora Serverless – A cloud-native and production-ready relational database?
Andreas Wittig gives his review of Amazon Aurora Serverless. This article outlines some of the benefits and limitations, and for the most part I agree. However, I do think the pricing is justified given the Multi-AZ availability and failover support that comes out of the box with Aurora Serverless. In order to achieve this with provisioned Aurora, you’d need to set up multiple instances which actually costs you more.

A top Microsoft cloud exec says that the company wants more customers to try out serverless computing, the ‘best way to do compute’
It looks like Microsoft is going all in on serverless too! Microsoft Azure CTO, Mark Russinovich, explains why serverless is the future of cloud computing. “We don’t want customers to stay out of the best way to do compute, and serverless is the best way to do compute.” I’d have to agree. 😉

Serverless September Content Collection
#ServerlessSeptember is in full swing, and Jan Schenk has put together a collection of all the great posts the Azure community is providing.

Tips and tools to achieve a serverless DevOps workflow
Kurt Marko outlines some of the basics of CI/CD and what the evolution of serverless means for your DevOps workflows.

Exclusive Research from Sumo Logic Reveals Multi-Cloud on the Rise and Open Source Technologies like Kubernetes is Disrupting the Modern Application Stack
This multi-cloud thing is not surprising to me, especially since I assume enterprises are more likely to hedge their best against the public cloud. Maybe this make sense for enterprises, but if you’re a startup or a mid-size company, I really think you’re handicapping yourself by going this route.

When you’ve got a long commute… 🚗

Serverless Chats – Episode #14: Serverless CI/CD for the Enterprise with Forrest Brazeal
In this episode, I chat with Forrest Brazeal about the CI/CD challenges facing enterprises, how to take a pragmatic approach to building pipelines for your serverless projects, and what tools are available to help you.

The Serverless Smarts Podcast – Ft. Erez Berkner, Visibility and Serverless Security
In the latest edition of the Serverless Smarts Podcast, Hillel Solow is joined by Erez Berkner from Lumigo to discuss visibility as a means to achieve better security, who is responsible for security – cloud provider or cloud customer, and edge computing in serverless.

Aleksandar Simovic AWS Serverless Hero Interview at Serverless Days Belgrade 2019
AWS Serverless Hero Aleksandar Simovic shares his thoughts on serverless during an interview at Serverless Days Belgrade.

Danilo Poccia AWS Principal Evangelist Interview at Serverless Days Belgrade 2019
Danilo Poccia talks about how to get started with serverless, its major benefits, and what some AWS customers are doing with it.

When you’re curious what the AWS devs have been up to… 👷‍♀️

Introducing NoSQL Workbench for Amazon DynamoDB — Now in Preview
This has definitely got some promise. I played around with it a bit and there are definitely some quirks (like I couldn’t figure out how to create a Local Secondary Index through the GUI), but I think this will go a long way to helping people create data models with DynamoDB. Read more about it here.

Announcing AWS PrivateLink support for Amazon Rekognition
Great update for everyone stuck in a VPC, though I still think the pricing for a NAT Gateway works out better if you need to access multiple services like this.

New Quick Start deploys clickstream analytics on the AWS Cloud
I really like these Quick Starts that AWS is putting out. You certainly don’t need to follow them exactly, but having the reference architecture out there is super helpful.

AWS Marketplace Makes It Easier to Deploy Lambda Functions with AMIs
You can now deploy your AMI-based solutions along with Lambda functions that interact with them, all with one CloudFormation template.

Serverless Tools 🛠

SAMWise (Beta)
Erik Peterson from CloudZero decided to build a SAM wrapper that makes deploying serverless applications easier. Inspiration struck while watching Lord of the Rings.

Not really a “serverless” tool, but reducing dependencies in your serverless functions is always a good idea to minimize package sizes and third-party vulnerabilities. If you’re building with Node.js, these handy native solutions can save you from leaning too heavily on your favorite utility libraries.

Noiiice Blog
Noiiice is a fully serverless blog platform with server-less side rendering. All services run on Amazon Web Services. The webapp is a Nuxt.js app served from a Lambda function using serverless-http through API Gateway.

If you really love managing Cassandra rings and needing an entire team to keep it up and running, as opposed to the fully-managed DynamoDB platform, here is a tool to help you easily take a step backwards. 😬

Thoughts from Twitter 🐦

#StrangeButTrueCloudFacts… (a thread) ~ Forrest Brazeal
Forrest provides us with nine interesting #StrangeButTrueCloudFacts. He ends his thread with an announcement of a book deal. Congrats to him!

Upcoming Serverless Events 🗓

There are a lot of upcoming serverless events, webinars, livestreams, and more. If you have an event you’d like me to mention, please email me.

September 18, 2019 – Our Serverless Journey – Dev Team Retrospective (Webinar)

September 19, 2019 – IOpipe and Mapbox Webinar: Visualizing critical, location-based metrics on serverless

September 20, 2019 – Serverless Transformation: An Online Panel Discussion

September 26, 2019 – Increasing Serverless Development Velocity (Webinar)

October 2, 2019 – Deep Dive on Amazon EventBridge (Webinar)

October 3, 2019 – How to Leverage Serverless to Optimize for Cost and Performance (Webinar)

October 7-9, 2019 – Serverlessconf 2019 in New York City

October 14-16, 2019 – Serverless Architecture Conference Berlin

October 24, 2019 –  ServerlessDays Stockholm

October 30, 2019 – Retail at the Scale of Serverless with AWS – Webinar

February 27, 2020 – Serverless Nashville – The CFP is now open!

Serverless Star of the Week ⭐️

There is a very long list of people that are doing #ServerlessGood and contributing to the Serverless community. These people deserve recognition for their efforts. So each week, I will mention someone whose recent contribution really stood out to me. I love meeting new people, so if you know someone who deserves recognition, please let me know.

This week’s star is Peter Sbarski (@sbarski). Peter is the VP of Content at A Cloud Guru, an AWS Serverless Hero, and he runs Serverlessconf (which is happening in NYC this October, BTW). Plus, he wrote a book about Serverless architectures on AWS, he’s a frequent speaker himself, and he’s one heck of a teammate for live Twitch coding challenges. 😉 The team over at A Cloud Guru is doing some amazing work helping to teach people about the cloud and serverless, and Peter is one of the driving forces behind it. Thanks for all you do, Peter (and we’ll take down Munns at re:Invent)! 🙌

Final Thoughts 🤔

Lots of really interesting things happening in the serverless ecosystem. It’s encouraging to see serverless shops like Stackery pushing forward with a new CEO and IOpipe getting recognized by Gartner. Plus, the Serverless Framework has been rapidly releasing features as part of their new full-lifecycle approach, as well as making a ton of improvements to their Microsoft Azure plugin. And speaking of Azure, there has been a huge push for serverless from Microsoft lately that is also great for the community. The more exposure it gets, results in faster adoption, faster innovation, and hopefully, more tools to make serverless even easier to use.

I hope you enjoyed this issue of Off-by-none. Please send me your feedback and suggestions as they help to make this newsletter better each week. You can reach me via Twitter, LinkedIn, Facebook, or email and let me know your thoughts, criticisms, or (perhaps) even how you’d like to contribute to Off-by-none.

If you like this newsletter, and think others would too, please do me the honor of sharing it with friends and coworkers who are interested in serverless.

Until next time,