Serverless API News

These are the news items I've curated in my monitoring of the API space that are related to serverless and APIs and thought worth enough to include in my research. I'm using all of these links to better understand how APIs are being deployed across a diverse range of implementations.

Title Source Visit
New ? Slack Integration Blueprints for AWS Lambda (2016-01-13)
Google has quietly launched its answer to AWS Lambda (2016-02-09)
Google Announces Cloud Functions, Takes on AWS Lambda (2016-02-11)
Running AWS Lambda Functions in AWS CodePipeline Using CloudFormation (2016-02-12)
Google Introduces Cloud Functions (2016-02-13)
Microcontainers - Tiny, Portable Docker Containers (2016-02-19)
Project Kratos Enables AWS Lambda Code to Run on Multiple Clouds (2016-02-21)
AWS Lambda-backed Custom Resources for Stack Outputs, Resources, and Parameters (2016-02-22)
Algorithmia is now free, forever (2016-03-01)
AWS Lambda Functions (2016-03-07)
Lambda of Lambda, if/Else From an Optional (2016-03-13)
Serverless Microservices in JavaScript (2016-03-18)
Serverless Delivery: Architecture (Part 1) (2016-03-20)
Implementing Slash Commands Using Amazon Lambda Functions ? Writing Tests (2016-03-21)
Sketching a Slack Slash Parliamentary Auto-Responder Using AWS Lambda Functions (2016-03-21)
GitHub - serverless/serverless: Serverless Framework ? Build and maintain web, mobile and IoT applications running on AWS Lambda and API Gateway (formerly known as JAWS) ? (2016-03-22)
Fresh from the press, Market scan: API Serverless Architecture (2016-03-23)
Microsoft launches AWS Lambda competitor Azure Functions in preview (2016-03-31)
Get a Job, Container: A Serverless Workflow with (2016-04-05)
Publishing Your Skill Code to Lambda via the Command Line Interface (2016-04-06)
Why A Cloud Guru Runs Serverless on AWS (2016-04-10)
Sending Amazon CloudWatch Logs to Loggly With AWS Lambda (2016-04-11)
Microsoft Gets into Serverless Apps with Azure Functions (2016-04-15)
Article: Lambda Functions versus Infrastructure - Are we Trading Apples for Oranges? (2016-04-21) - an open source pastebin with runnable snippets and API (2016-04-23)
Sap Tv Asks to Explain Microservices (2016-04-26)
MagicStack: A serverless API platform that gives you more features with less code (2016-04-26)
DevOps gold nuggets: scaling down gracefully with AWS Lambda and HAProxy (2016-04-27)
Introducing Lambda Support on (2016-04-27)
Serverless Architectures on AWS (2016-05-02)
Java 8: Lambda Functions?Usage and Examples (2016-05-04)
Reducing complexity with serverless API architecture (2016-05-06)
Now API ? Instant serverless Node.JS deployments with an API. (2016-05-10)
Integrate SQS and Lambda: Serverless Architecture for Asynchronous Workloads (2016-05-26)
Serverless Microservices (and Minimal Ops): Current Limitations of AWS Lambda (2016-06-17)
What Is Serverless? (2016-06-17)
Serverless Data Sync in Web Apps With Bit Torrent (2016-06-17)
The next big thing: Serverless (2016-06-17)
A Look at Serverless Architectures (2016-06-20)
Building serverless apps with Docker (2016-06-21)
FaaS, PaaS, and the Benefits of the Serverless Architecture (2016-06-25)
OpenShift Ecosystem: Brings a Serverless Experience to OpenShift (2016-06-29)
Building Serverless Apps With (2016-07-03)
The Life of a Serverless Microservice on AWS (2016-07-04)
Serverless: Invalidating a DynamoDB Cache (2016-07-10)
Serverless Big Data Pipeline on AWS (2016-07-18)
Learn how @smartnews built a Lambda Architecture on AWS to recommend content to customers! (2016-07-18)
Building Serverless Apps with AWS Lambda (2016-07-19)
Command Everything With a Serverless Slack Bot (2016-07-26)
Error Reporting for AWS Lambda (2016-08-01)
Brightwork ? Develop serverless apps using Javascript (2016-08-02)
Building Serverless Apps With AWS Lambda (2016-08-03)
Create a Serverless RESTful API on AWS (2016-08-05)
Webda ? Welcome to Serverless Applications (2016-08-08)
4 Steps To Secure Serverless Applications (2016-08-08)
Where AWS is headed: Every function as a managed cloud service (2016-08-11)
Create a Serverless RESTful API With the Serverless Framework (2016-08-14)
The Data Briefing: Microservices and Serverless Apps ? A New Direction for Federal Government Mobile Apps? (2016-08-24)
Serverless Elasticsearch Curator on AWS Lambda (2016-08-29)
Serverless Computing and Microservices With and Mesosphere (2016-08-29)
Lambda vs IronWorker (2016-08-29)
A Container Is A Function Call (2016-08-31)
Do?s and Don?ts of AWS Lambda (2016-09-13)
Monitoring Serverless Architectures, Microservices and Containerized Applications (2016-09-14)
Build a Serverless Slack Bot with (2016-09-14)
A new serverless adventure at Auth0 (2016-09-19)
Serverless Architectures: The Evolution of Cloud Computing (2016-09-22)
Challenge Accepted: Building A Better Australian Census Site with Serverless Architecture (2016-09-22)
Troy Hunt: Azure Functions in practice (2016-09-23)
New Alexa Technical Tutorial: Debugging AWS Lambda Code Locally (2016-09-27)
Serverless WebSocket chat (2016-09-29)
Running Express Applications on AWS Lambda and Amazon API Gateway (2016-10-04)
GitHub - dougmoscrop/serverless-http: Middleware wrapper for serverless use (2016-10-07)
Building A Serverless Screenshot Service with Lambda (2016-10-14)
Automatically convert files in S3 buckets using AWS Lambda (2016-10-17)
Lambda Architecture with Apache Spark (2016-11-03)
The Power of Java 8 Lambdas for REST API Development (2016-12-13)
Making Spring Boot Applications Run Serverless With AWS (2016-12-18)
REST With Lambdas and Wicket 8 (2016-12-29)
Triggering Lambda Functions With an AWS IoT Button (2016-12-30)
Splunk and AWS: Monitoring Metrics in a Serverless World (2017-01-06)
Serverless Microservices With AWS and Couchbase (2017-01-09)
Indexing Metadata in Amazon Elasticsearch Service Using AWS Lambda and Python (2017-01-09)
AWS Lambda Performance and Cold Starts (2017-01-12)
AWS Lambda - A Look Back at 2016 (2017-01-14)
Ten Attributes of Serverless Computing Platforms (2017-01-19)
Automatic SlideShare Text Summarization (2017-01-19)
Fission Serverless Functions as a Service for Kubernetes (2017-01-30)
Writing a cron job microservice with Serverless and AWS Lambda (2017-01-30)
Platform9s Fission Puts an Open Source Spin on Serverless (2017-01-31)
How Lambdas And Anonymous Inner Classes Work (2017-02-07)
Removing Duplicate Code With Lambda Expressions (2017-02-08)
Understanding Serverless Cloud and Clear (2017-02-09)
The Freedom of AWS Lambda (2017-02-14)
Meet Backands New Serverless SDK (2017-02-14)
Building a Serverless Application with Stormpath Authentication (2017-02-15)
The Benefits of a Serverless API Backend (2017-02-16)
5 Potential Use Cases for Serverless Frameworks (2017-02-18)
Serverless REST API with Angular, Persistence and Security (2017-02-22)
Serverless REST API with Angular, Persistence and Security (2017-02-24)
write serverless functions using aws lambda and c# (2017-02-24)
Integrate AWS Lambda into your Backendless apps (2017-02-24)
Seeking Simple #Serverless Orchestration? Check out new #StepFunctions Lambda (2017-02-24)
Serverless Swift on OpenWhisk (2017-03-02)
Upgrade Your Apps to Work with Our New Serverless SDK (2017-03-02)
Serverless Architectures on AWS (2017-03-02)
Best practices AWS Lambda function (2017-03-03)
Adapting Serverless Architecture (2017-03-04)
Serverless Computing: Dont Throw Your Servers Away Just Yet (2017-03-10)
Using Serverless Azure Functions with Auth0 and Google APIs (2017-03-10)
Continuously Encrypt Amazon Redshift Loads with S3, KMS, and Lambda (2017-03-10)
Understand Serverless Architecture in Three Minutes (2017-03-15)
A Nice API Design Gem: Strategy Pattern With Lambdas (2017-03-16)
Automating AWS Lambda Function Error Handling with AWS Step Functions (2017-03-16)
Build a Serverless Slack Bot in 9 Minutes with Node.js and StdLib (2017-03-21)
Build Lambda Expressions Dynamically (2017-03-21)
Storing Tweets With AWS Lambda and Scheduled Events (2017-03-21)
What to Look for When Choosing a Serverless Architecture (2017-03-23)
Applying Lambda Architecture on Azure (2017-03-23)
IBM Advances OpenWhisk Serverless Computing Initiative (2017-03-23)
Serverless Stack - Step-by-step tutorials for creating serverless React.js apps (2017-03-23)
Serverless does *not* mean NoOps (2017-03-24)
Let serverless solve the technology problems you dont have (2017-04-04)
AWS Lambda: Encrypted Environment Variables (2017-04-06)
If you missed my #OpenWhisk Pig Latin Twitterbot workshop at #IBMInterConnnect I have posted full instructions (2017-04-06)
How to Go From Zero to Serverless With Backand (Part 1) (2017-04-10)
Deploying Your Serverless Functions to Google Cloud Platform (2017-04-13)
AWS X-Ray Update General Availability, Including Lambda Integration (2017-04-19)
How to Go From Zero to Serverless, Conclusion (2017-04-19)
Watson Service Chaining With OpenWhisk (Part 1 of 3) (2017-04-20)
Announcing the AWS Chatbot Challenge Create Conversational, Intelligent Chatbots using Amazon Lex and AWS Lambda (2017-04-21)
Serverless Architecture (Part 1) (2017-04-22)
Switching OpenWhisk Environments (2017-04-22)
Considerations for Moving Services to AWS Lambda (2017-05-01)
Lessons Learned in Lambda (2017-05-01)
Serverless Takes DevOps to the Next Level (2017-05-03)
Serverless Works Best in API Architectures (2017-05-09)
Serverless Air #2 (2017-05-15)
This is not the Serverless I Ordered (2017-05-16)
Serverless Webhooks with Auth0 Extend (2017-05-19)
Firebase Cloud Functions (or how to run code on Firebase servers!) (2017-05-21)
An essential guide to the serverless ecosystem (2017-05-21)
Connecting Intercom and Slack with a Serverless Webhook (2017-05-24)
Serverless and GraphQL: A Perfect Match for the New Cloud Paradigm (2017-05-24)
Serverless Tutorial: File Storage with Webtask and Cloudinary (2017-05-24)
The Who, What, When, Where, and Why of Serverless (2017-05-26)
ks888/LambStatus: Serverless Status Page System (2017-05-27)
Serverless Isnt About Cost Savings, Its About At (2017-06-01)
Integrating Algorithmia with Apache Spark (2017-06-05)
Databricks releases serverless platform for Apache Spark along with new library supporting deep learning (2017-06-06)
Think Twice Before Decomposing Your Apis For Serverless (2017-06-06)
Red Hat and Apache OpenWhisk (2017-06-07)
Databricks Serverless: Next Generation Resource Management for Apache Spark (2017-06-07)
Serverless and the the death of devops. Can you not? James Governors Monkchips (2017-06-08)
Text for your sales reports using Twilio Functions and Square (2017-06-09)
AWS Greengrass Run AWS Lambda Functions on Connected Devices (2017-06-12)
The Serverless Learning Curve (2017-06-12)
Announcing Azure Functions OpenAPI (Swagger) support preview (2017-06-12)
Using Serverless to Simplify and Automate AWS Lambda (2017-06-12)
How Serverless Is Shaping the Future of Software Development (2017-06-13)
Skipping Containers Altogether for Serverless Environments (2017-06-15)
Intro to the Serverless Framework: Building an API (2017-06-15)
OpenWhisk, Bluemix, and Event (2017-06-16)
The Need for Infrastructure Tooling in the Serverless Ecosystem (2017-06-19)
Release Release 0.5 awslabs/aws (2017-06-20)
5 Handy Serverless APIs for Web Development (2017-06-22)
AWS Lambda: Sync or Async? (2017-06-22)
The Need for Asynchronous RPC Architecture in Serverless Systems (2017-06-23)
Im here to tell you the truth, the good, the bad and the ugly of AWS X (2017-06-26)
Five Advantages of Serverless Technology (2017-06-26)
Defining Serverless Part 3 (2017-06-26)
Dont dip your toes in serverless you have to dive right in (2017-06-27)
Start with Serverless framework (2017-06-27)
Unintended future consequences (2017-06-27) Serverless API (2017-06-27)
Cost: The driver of serverless architectures (2017-06-27)
<stdlib> A Standard Library For The Web (2017-06-27)
Defining Serverless Part 4 (2017-06-27)
Serverless Swift With OpenWhisk (2017-06-27)
GitHub (2017-06-28)
StdLib Function as a Service Software Library (2017-06-28)
Yubls road to Serverless Part 5, Building better recommendations with Lambda, BigQuery and (2017-06-28)
Defining Serverless Part 5 (2017-06-28)
Serverless: AWS Lambda (2017-06-30)
What's your serverless maturity level? (2017-06-30)
Technically, its not serverless if youre going online to use other peoples servers for each area (2017-06-30)
Designing Web APIs using Google Firebase Functions: Achieving True Routing (2017-07-01)
Why Serverless architectures are great for custom solutions! (2017-07-03)
Some thoughts on using AWS Lambda with Slack Webhooks (2017-07-03)
How long does AWS Lambda keep your idle functions around before a cold start? (2017-07-03)
Five Reasons Why Server (2017-07-03)
Serverless and why I dislike RDBMS (2017-07-04)
Introducing Backbench beta (2017-07-04)
Serverless Computing (2017-07-04)
Simple email validation service using AWS Lambda & Zappa (2017-07-04)
Write, Launch, Forget: Building a Chatbot on Cloud Functions (2017-07-04)
CloudBoost vs Firebase: A War of choices. (2017-07-05)
Delivering Content Using Google Sheets, Lambda, API Gateway, and Cloudfront (2017-07-05)
Handling SMS with OpenWhisk, IBM Watson and Twilio an Update (2017-07-07)
What is Serverless Computing and Why is it Important (2017-07-07)
Serverless Amazon Alexa Skills (2017-07-07)
Hybrid Serverless Architecture (2017-07-08)
I finally feel like a user developers praise for The Serverless Framework (2017-07-09)
Tips & Tricks: Registering a New Data Function (2017-07-10)
Thinking about a serverless API concept for PowerShell Tasks (2017-07-10)
In 5 years from right now, all servers will cease to exist (2017-07-10)
Call AWS Lex Intent from Lambda Function using API (2017-07-11)
Why we build serverless web and mobile apps. (2017-07-11)
Developer Experience Lessons Operating a Serverless (2017-07-11)
Serverless github bot with AWS Lambda and API Gateway (Node.js) (2017-07-11)
My Serverless Frankenstein for Honeypots (2017-07-12)
Announcing Serverless workshops! (2017-07-12)
Serverless and npm native modules (2017-07-12)
Easy Custom Domains For Serverless APIs (2017-07-12)
A lambda invoking a lambda. Locally! (2017-07-13)
Feature velocity and Serverless (2017-07-13)
Serverless Continuous Delivery with Databricks and AWS CodePipeline (2017-07-13)
Assessing the Current State of Serverless Security (2017-07-13)
Feature Acceleration and Serverless (2017-07-14)
Google Cloud Functions, Serverless framework and environment variables. (2017-07-16)
Leveraging Google Cloud for building a serverless image tagging service part 1 (2017-07-16)
Creating Swift Binaries for OpenWhisk (2017-07-16)
Webtask An Alternative For A Back (2017-07-16)
Creating a Serverless Meetup API Wrapper (2017-07-17)
Serverless: Creating a Webhook Consumer in 5 minutes (2017-07-18)
Public & Cross (2017-07-18)
Google not Amazon Make fantastic savings in a serverless world (2017-07-18)
Supercharging a static site with [email protected] (2017-07-19)
Unveiling Amazons hidden plans for AWS Lambda (2017-07-21)
Make a Web Scraper with AWS Lambda and the Serverless Framework (2017-07-23)
Unlocking serverless computing: using AWS Lambda in EC2 Classic (2017-07-24)
Sharing Usefulness Easy serverless web services. (2017-07-24)
Revisiting AWS Lambda Runtime Performance (2017-07-24)
Using Postman with OpenWhisk (2017-07-24)
Data processing with Slack and serverless backend on AWS (2017-07-24)
Do you need a server? (2017-07-25)
Function (2017-07-25)
Store finder: our technology approach (2017-07-25)
Introducing OpenWhisk Shell (2017-07-26)
Speedy JSON Endpoints with Rails (2017-07-26)
Running and debugging AWS Lambda functions locally with the Serverless framework and VS Code (2017-07-27)
JavaScript Gets an Onramp to Lambda Serverless with the Open Source Architect Tool (2017-07-27)
Serverless Web Pages with One (2017-07-27)
Node Summit Highlights Serverless, Parallel JavaScript (2017-07-28)
Serverless Dynamodb Local Unit Testing (2017-07-29)
How I cut my AWS bill by 90% (2017-07-30)
Tracking Activity with OpenWhisk Shell (2017-07-30)
The Best DevOps is NoOps (2017-07-31)
While a completely stateless and auto scalable infrastructure is desirable even by Ops people (2017-07-31)
A New Serverless Plugin: Kubeless (2017-07-31)
Serverless Computing: Your Next Step Beyond the Cloud (2017-07-31)
AWS Lambda Power Tuning with AWS Step Functions (2017-08-01)
Auth0 Webtasks: The Quickest of All Quick Starts (2017-08-01)
Porting to serverless (2017-08-02)
Trigger Periodic OpenWhisk Actions (2017-08-02)
From RPC to Serverless, Prefabricated PaaS Accelerates Business Velocity (2017-08-02)
Exploring Serverless with Python, StepFunctions, and Web Front (2017-08-02)
Untitled ( (2017-08-03)
A Hackathon Team May Have Discovered Serverless Done Right (2017-08-03)
Continuous Engineering with the Serverless Framework (2017-08-03)
Large Applications on OpenWhisk (2017-08-03)
Time2Code: Functions as Service and Code as a Function. (2017-08-03)
Implementing Serverless Manual Approval Steps in AWS Step Functions and Amazon API Gateway (2017-08-05)
Serverless is so far one of the best things that happened in programming for me (2017-08-06)
Serverless is the jump before Ethereum Smart Contracts (2017-08-07)
Setting up a Severless project with Typescript (2017-08-07)
5 reasons Red Sift Cloud is better than AWS Lambda (2017-08-08)
5 Things to Know About AWS Lambda: Running Lambda Functions Concurrently (2017-08-08)
Introducing the Serverless GraphQL Backend Architecture (2017-08-08)
Amazon Web Services Lambdas Hello, World! (2017-08-09)
Applying the pub (2017-08-09)
How AWS [email protected] Service Could Ease Web Content Personalization (2017-08-09)
A Non (2017-08-09)
Serverless is so much easier than instances (2017-08-09)
Why does Serverless matter? (2017-08-09)
Build a Serverless API in Seconds with Go Serif & Semaphore (2017-08-09)
Going Serverless with PubNub Functions (2017-08-09)
Launching EC2 Instances from Lambda (2017-08-09)
Applying the decoupled invocation pattern with AWS Lambda (2017-08-10)
6 Reason Serverless Computing Can Take the Cloud to the Next Level (2017-08-10)
AWS Lambda vs Google Cloud Functions vs Azure functions: who has the serverless advantage? (2017-08-10)
Add Redis To Your Serverless Application (2017-08-10)
Monitor Stack Overflow activity directly into Slack (2017-08-10)
Server (2017-08-10)
Up (2017-08-10)
AWS Lambda & API Gateway Network Computer Player (2017-08-11)
A Serverless way to serve more (2017-08-11)
Putting Your Lambda In A VPC (2017-08-11)
I really like this approach to serverless deployments / infrastructure management. (2017-08-12)
Serverless Web Applications with CI/CD in AWS (2017-08-12)
Rigetti Introduces Developers to Quantum Computing Through a Serverless API (2017-08-14)
AWS Lambda and Internet (2017-08-14)
With $2.5M in seed funding, IOpipe brings monitoring to serverless applications (2017-08-14)
Announcing IOpipe 1.0 (2017-08-14)
How to create a simple REST web (2017-08-15)
Serverless: IOpipe Launches a Monitoring Tool for AWS Lambda (2017-08-15)
Implement voice controls for a serverless home automation hub (2017-08-16)
Leverage AWS CloudFront for Serverless Web Applications using Go (2017-08-16)
Serverless beyond Functions (2017-08-17)
Introducing Geolambda Development Seed (2017-08-17)
The people side of serverless adoption (2017-08-17)
Hack day experiments with the cloud and orchestration of serverless functions (2017-08-18)
Why Event Grid is a game (2017-08-18)
Learning Lambda Part 6 (2017-08-18)
Does AWS Lambda keep its serverless marketing promise of continuous scaling? (2017-08-18)
Your first serverless .NET function with OpenFaaS (2017-08-18)
Can [email protected] make AWS CloudFront the most flexible CDN out there? (2017-08-19)
This Week in Numbers: Serverless Adoption on Par with Containers (2017-08-19)
How Canon Almost Started The Serverless Revolution (2017-08-20)
Make apps smarter with serverless (2017-08-20)
Serverless vs Client (2017-08-20)
How to: Easy Serverless AWS GraphQL API (2017-08-21)
Write recursive AWS Lambda functions the right way (2017-08-21)
Its all going to be serverless the question is When? (2017-08-21)
Serverless Autocomplete (2017-08-21)
Building a Serverless E (2017-08-21)
Deploying a Kubeless function using Serverless templates (2017-08-21)
Building serverless (event (2017-08-21)
Write recursive AWS Lambda functions the right way Hacker Noon (2017-08-22)
Function (2017-08-22)
Serverless contact us form for static websites (2017-08-22)
Function (2017-08-22)
Microsoft Serverless Computing Plans Gains Intelligent Traffic Co (2017-08-22)
Untitled ( (2017-08-23)
100% Serverless (2017-08-23)
Serverless: The New Cloud Trend (2017-08-23)
Evaluating TensorFlow Models in AWS Lambda (2017-08-24)
Announcing the launch of ap (2017-08-24)
Hey! Go Serverless, and #freeyourservers (2017-08-24)
Using Azure Functions (2017-08-24)
Best Practices for Working with AWS Lambda Functions (2017-08-24)
Serverless: Functions in the Cloud (2017-08-25)
Using ngrok with Azure Functions (2017-08-26)
A Comprehensive Guide to Google Cloud Functions (2017-08-27)
Receiving Email using SES, S3 and Route53 (2017-08-27)
Small Functions considered Harmful Cindy Sridharan Medium (2017-08-27)
Serverless computing: Its all about functional stateless microservices (2017-08-27)
Basic Serverless Tutorial With Node.js (2017-08-28)
Serverless computing, what problems does it solve? (2017-08-29)
3 Questions about Serverless Technology (2017-08-29)
Secure and Manage AWS Lambda Endpoints with Kong (2017-08-29)
Go Serverless with SAM for local dev & test (2017-08-29)
Secure and Manage AWS Lambda Endpoints with Kong (2017-08-29)
Is your Serverless as good as you think it is? (2017-08-29)
What is Serverless Computing? (2017-08-29)
3 pro tips to speed up your Java (2017-08-29)
De (2017-08-30)
Why serverless makes sense (2017-08-30)
Serverless: password protecting a static website in an AWS S3 bucket (2017-08-30)
Apache OpenWhisk + The Serverless Framework: PHP Support, Docker runtime and more (2017-08-31)
Capture and forward correlation IDs through different Lambda event sources (2017-09-01)
Technology never wins in business, but Serverless is the best shortcut I know (2017-09-01)
AWS API Gateway to hide request credentials (2017-09-01)
Writing Less Serverless code with Vandium (2017-09-01)
Redirects at the Edge (2017-09-01)
Monitor your AWS CodeBuilds via Lambda and Slack (2017-09-01)
Polling Architecture with Serverless and Node.js (2017-09-01)
New Paradigms: Serverless (2017-09-02)
AWS Lambda Useful links (2017-09-02)
OpenFaaS on Rancher (2017-09-02)
Automated Lambda Deployments with Terraform & CodePipeline (2017-09-02)
Performance Tuning Alexa Skills using AWS Lambda (2017-09-04)
Bitnami, Partner to Deliver Turn (2017-09-05)
Overview of Functional Programming (2017-09-05)
Automated Lambda Deployments with Terraform & CodePipeline (2017-09-05)
Serverless By Design (2017-09-06)
Tutorial for building a Web Application with Amazon S3, Lambda, DynamoDB and API Gateway (2017-09-06)
Serving 1x1 pixels from AWS Lambda endpoints (2017-09-06)
AWS Lambda is HIPAA eligible (and 7 other updates) (2017-09-06)
Global try (2017-09-06)
Rise of Functions as a Service: How PHP Set the Serverless Stage 20 Years Ago (2017-09-07)
A simple definition of Serverless (2017-09-08)
Self Service Database Resets with the Serverless Framework and Slack (2017-09-09)
Integrating OpenFaas and GraphQL (Experimental) (2017-09-09)
Serverless Timeline (2017-09-10)
Why is Serverless Extensibility better than Webhooks? (2017-09-11)
Parallel Processing in Python with AWS Lambda (2017-09-11)
From Servers to Serverless (long (2017-09-11)
How to secure Serverless applications (2017-09-13)
How to upload photos to the cloud with Swift3 and a serverless platform (2017-09-13)
AWS Lambda LiveLessons (2017-09-13)
Serverless Superheroes: Adam Johnson, Monitoring, and the No Ops Myth (2017-09-13)
The Emerging GraphQL and Serverless Stack for Building Static Web Sites (2017-09-14)
A Quick Introduction to Functional Javascript (2017-09-14)
The State of The Serverless Ecosystem (2017-09-14)
Implementing Serverless Node.js Functions Using Google Cloud (2017-09-15)
Leveraging AWS Lambda for Image Compression at scale (2017-09-17)
The Future of Serverless (2017-09-18)
Getting started with OpenWhisk Deploy (2017-09-18)
Under (2017-09-19)
Serverless and Auth0 Webtasks, hop on the bullet train (2017-09-20)
Azure Function Apps with Python (2017-09-20)
Build a Serverless Ping Service + Status Page in 5 Steps with StdLib Scheduled Tasks (2017-09-20)
Mind the 75GB limit on AWS Lambda deployment packages (2017-09-20)
How to monitor Lambda functions (2017-09-20)
Build a Serverless Ping Service + Status Page in 5 Steps with StdLib Scheduled Tasks (2017-09-20)
Coming out of the fold: Announcing our $15m Series A (2017-09-21)
Going Serverless: A Primer on AWS Lambda (2017-09-21)
OpenFaaS on Azure: Soup to Nuts (2017-09-21)
Build a professional serverless web service with AWS CodeStar (2017-09-21)
Walkthrough: Building A Database (2017-09-22)
Processing 100,000 Events Per Second on Azure Functions (2017-09-22)
Publish a website without a (propper) server (2017-09-23)
A Serverless GraphQL Blog in 60 Seconds with OpenFaaS (2017-09-23)
Serverless Slack Commands with Go & The Serverless Framework (2017-09-23)
Serverless: using serverless module for CD (2017-09-24)
How to build a server (2017-09-24)
How to load test a realtime multiplayer mobile game with AWS Lambda and Akka (2017-09-25)
Serverless Superheroes: Eric Hammond, AWS Lambda, and the Power of Code (2017-09-25)
Deploying a serverless Youtube (2017-09-25)
Whats Next for the Serverless Platform (2017-09-26)
Go Serverless with Kubeless! (2017-09-26)
Creating a Serverless Python API Using AWS Lambda & Chalice (2017-09-27)
The coming wave of serverless services (2017-09-27)
Serverless, Serverfull, and Weaving Pipelines (2017-09-27)
Fast API Prototyping with and Serverless. (2017-09-28)
Clojure in AWS Serverless: New Direction (2017-09-29)
Why does your Serverless application have so many servers? (2017-09-29)
Miserlou/Zappa: Serverless Python Web Services (2017-09-29)
Go Serverless with Azure Functions and C# (2017-10-01)
Telegram Bot Prototype using Serverless Framework and Webtask (2017-10-02)
Pros and Cons of Developing Serverless Slack Apps with Java (2017-10-02)
Serverless ETL on AWS Lambda (2017-10-02)
The Fn Serverless Project is Now Available (2017-10-02)
Platform9s Fission Workflows makes it easier to write complex serverless applications (2017-10-03)
Realizing The Promise Of Functional Services (2017-10-03)
Using Relational Databases With Serverless Functions (2017-10-03)
Serverless Hapi Services Using Stackery (2017-10-03)
Error Handling In A Serverless World (2017-10-03)
Serverless Use Cases (2017-10-03)
Serverless Is Awesome For APIs (2017-10-03)
The Serverless Learning Curve (2017-10-03)
Stackery Supports Python (2017-10-03)
Whats your serverless maturity level? (2017-10-03)
Serverless Amazon Alexa Skills (2017-10-03)
Porting to serverless (2017-10-03)
The people side of serverless adoption (2017-10-03)
Introducing the CDN node (2017-10-03)
The Future of Serverless (2017-10-03)
All things AWS (and serverless) with the Cloud Gurus (2017-10-03)
Deploy Your Cloud Functions with Bluemix DevOps (2017-10-04)
How We Monitor AWS Lambda at OpsGenie with Thundra (2017-10-04)
Serverless Audio Transcription (2017-10-04)
Lets Learn Azure Functions Together (2017-10-04)
Building & Monitoring a Fullstack Serverless App (2017-10-04)
Cloudant Envoy: Serverless Edition (2017-10-05)
Why isnt Serverless obvious to everyone? (2017-10-05)
How Dubsmash uses [email protected] to serve dynamic SPA using S3 (2017-10-05)
Serverless. Lets make it clear! (2017-10-06)
Building a data lake in S3 using an event (2017-10-06)
Using AWS API Gateway and Step Functions without Exposing Your ARN (2017-10-06)
Creating a Serverless Uptime Monitor & Getting Alerted by SMS Lambda, Zappa & Python (2017-10-06)
Start with AWS Serverless (2017-10-07)
The (Futile) Resistance to Serverless (2017-10-07)
Automated Deployment of Serverless and React using AWS CodePipeline (2017-10-07)
Serverless Aggregations on AWS Lambda with Node.js Codebase (2017-10-08)
Blockspring Scripts (2017-10-08)
All my posts on Serverless & AWS Lambda (2017-10-08)
OpenFaaS: Run Any Containerized Command Line App as a Serverless Function (2017-10-09)
Interactive serverless no free lunch (2017-10-09)
Demystifying Serverless Compute Manifesto (2017-10-10)
Rebuilding full text search in Go for our server (2017-10-10)
Expanding Azure Functions to the Cosmos (2017-10-10)
Why IoT and Serverless Fit So Well! (2017-10-10)
Connecting the Enterprise with Azure Event Grid and Serilog (2017-10-10)
Composing Serverless Apps with IBM Cloud Functions (2017-10-10)
Vendor Lock (2017-10-10)
Canarying and blue/green deployments in Lambda (2017-10-10)
StdLib: A Serverless Library for Building Developer Velocity (2017-10-11)
I migrated from LEMP to serverless, should you? (2017-10-11)
Serverless: Follow up on my last post (2017-10-11)
Serverless JavaScript, OMG (2017-10-11)
Stupid question of the day #2: What is Serverless and what is has to do with cloud? (2017-10-11)
Serverless At The Helm in Kubernetes in the DevNet Sandbox (2017-10-11)
API Strict Parties Update (2017-10-12)
Developer Experience Lessons Operating a Serverless (2017-10-12)
Serverless Fortran Code Execution w/ Time2Code and OpenFaaS (2017-10-12)
Serverless Function Architecture Principles (2017-10-13)
Stackery and the Emerging Adoption Paths for Serverless (2017-10-13)
Choosing a Python Serverless framework (2017-10-13)
A Serverless Data Architecture Is it possible? (2017-10-13)
Serverless Architecture (2017-10-15)
Serverless Allergy Checker with Amazon Rekognition, Lex, Polly, DynamoDB, S3 and Lambda (2017-10-15)
Flow 101 (2017-10-16)
Flow 102 (2017-10-16)
Composing functions into applications (2017-10-16)
Scheduled functions with OpenFaaS (2017-10-16)
Bots helped me understand Serverless Architectures / Services (2017-10-16)
Serverless availability zones are the missing level of resiliency for AWS (2017-10-16)
Serverless Function Architecture Principles (2017-10-17)
Monitoring Fantasy Football Using New Relic Insights and AWS Lambda Integration (2017-10-18)
The Serverless Stack (2017-10-18)
Introducing StdLib Sourcecode: Share Your Node.js Serverless Code With Developers Worldwide (2017-10-19)
nuclio: The New Serverless Superhero (2017-10-19)
Why You Should Use API Gateway Proxy Integration With Lambda (2017-10-19)
Serverless is about Automation, not Functions (2017-10-20)
Throttle Lambda Invocations with SNS (2017-10-20)
Building a Serverless Content Repository (2017-10-21)
The perf is not just for in mem, nuclio uses async and zero (2017-10-21)
Serverless API with Claudia.js in 3 Steps (2017-10-21)
Youtube to MP3 using S3, Lambda & Elastic Transcoder (2017-10-21)
An Introduction to Serverless DevOps with OpenFaaS (2017-10-21)
Hello World with AWS API Gateway and Lambdas (2017-10-22)
Lets set the record straight on the term serverless and what its not (2017-10-22)
Your first serverless multi (2017-10-22)
2 years with AWS Lambda (2017-10-22)
Things that you should know about new open source serverless platform: Fn (2017-10-23)
Build a Serverless Memes Function with OpenFaaS (2017-10-24)
The duality between serverless functions and APIs (2017-10-24)
AWS FAAS leadership is noted by the integration with Serverless Framework and GraphQL, but (2017-10-24)
Serverless Telegram bot on AWS Lambda (2017-10-25)
Many (2017-10-25)
What is Serverless? Part 2: What is a Serverless architecture? (2017-10-25)
Introducing Jazz: T (2017-10-25)
AWS Lambda Python Library Zappa Unzipped (2017-10-25)
Serverless Operations 101 (2017-10-26)
How can we apply the principles of chaos engineering to AWS Lambda? (2017-10-26)
Testing programming models (2017-10-26)
Create a Serverless REST API with Node.JS, AWS Lambda, DynamoDB & API Gateway (2017-10-26)
Setup AWS Lambda with Scheduled Events (2017-10-26)
Serverless Operations 101 (2017-10-26)
What is Serverless Computing? (2017-10-26)
Amtrak Rolls Past Containers into a Serverless Infrastructure (2017-10-27)
Going Serverless (2017-10-27)
Lambda (2017-10-27)
Death to Servers: Why serverless is the next major evolution of the internet (2017-10-29)
serverless (2017-10-29)
Some lessons learned about Lambda orchestration (2017-10-30)
Serverless Framework: Securing AWS Lambda Endpoints (2017-10-30)
Serverless ‘Glue’ apps in AWS, and sending Slack notifications for Code Pipeline Events (2017-10-30)
Adventures in Migrating to Serverless (2017-10-30)
Hyperdoc project has born (2017-10-30)
Everything You Need To Know About Serverless Architecture (2017-10-30)
Build a “Serverless” Reddit Bot in 3 Steps with Node.js and StdLib Sourcecode (2017-10-31)
Nuclio and the Future of Serverless Computing (2017-10-31)
AWS Elasticsearch/Kibana for Serverless Log Aggregation (2017-11-01)
The Serverless Spectrum (2017-11-01)
Learning Lambda — Part 7 (2017-11-01)
Azure Durable Functions: Making Serverless Last (2017-11-02)
The State of Serverless Security — Fall/2017 (2017-11-02)
Serverless Cost Reduction (2017-11-02)
Is it easy to integrate with GraphQL and Serverless framework? (2017-11-02)
Binary responses with Serverless Framework and API Gateway (2017-11-02)
Serverless: Moderate fun with Modular Functions (2017-11-04)
OpenFaaS: Serverless with Docker (2017-11-04)
An Introduction to Serverless and FaaS (Functions as a Service) (2017-11-05)
Serverless (2017-11-05)
What can you do with Azure Functions? Here’s one example. (2017-11-05)
Applying principles of chaos engineering to AWS Lambda with latency injection (2017-11-06)
Containers vs Functions (2017-11-06)
Serverless Architectures — AWS Lambda (2017-11-07)
Going Serverless (2017-11-07)
Run AWS Lambdas Locally (Python 3.6) (2017-11-07)
I wish I knew how to use MongoDB connection in AWS Lambda (2017-11-07)
Functional programming paradigms in modern JavaScript: Pure functions (2017-11-08)
Serverless is DevOps (2017-11-09)
Using IBM Cloud Functions to Create Serverless Microservices (2017-11-09)
Running Spring Integration as AWS Lambda Function — Serverless (2017-11-09)
Do Serverless and Abstract Architectures Have a Place in DevOps? (2017-11-09)
Learning Lambda (2017-11-09)
Serverless Demystified (2017-11-11)
Contributing to OpenFaaS without writing any code… (yet) (2017-11-11)
Serverless: Looking Back to See Forward (2017-11-12)
Serverless Automation: Services as Code (SaC) (2017-11-12)
The Move to Serverless… Digital Ocean, Heroku, AWS, OH MY! (2017-11-13)
FunctionCI — Continuous Integration for Serverless Functions (2017-11-13)
AWS Serverless Cooking with Lard (Part 1) (2017-11-13)
Learning Lambda — Part 8 (2017-11-14)
Serverless frameworks and containers (2017-11-14)
Full Stack Serverless Web Apps with AWS (2017-11-14)
Serverless Framework not for serious use (2017-11-14)
Running cron jobs on AWS Lambda with Scheduled Events (2017-11-15)
Is AWS Lambda just another Platform as a Service? (2017-11-15)
Lambda computing with Minio and Kafka (2017-11-15)
Tracking Your Cryptocurrency Portfolio With Serverless Functions (2017-11-16)
gzip on AWS Lambda and API Gateway (2017-11-16)
Learning Lambda — Part 9 (2017-11-16)
Working with Azure functions: build quality in (2017-11-16)
What is Serverless? (2017-11-16)
How to create Environment variables in Eclipse, JAVA and AWS Lambda (2017-11-17)
Serverless Battle: AWS Lambda vs Parse Cloud Code (2017-11-17)
The Many Potential Benefits of Serverless Computing (2017-11-17)
Funtainers: The Beauty of Running Containers as Functions (2017-11-17)
Lean Dashboards — the Serverless Way (2017-11-19)
Using Azure Functions to process Stripe payments (2017-11-19)
Building a Twitter Reader with a Serverless API (2017-11-21)
6 Vital Things to Know About Serverless Tech (2017-11-21)
How we monitor Serverless apps with hundreds of functions (2017-11-21)
Collapsing AWS lambdas (2017-11-21)
Serverless Transactions Serve Customers (2017-11-21)
Rate Limiting Serverless Apps — Two Patterns (2017-11-21)
AWS Lambda in Production: State of Serverless Report 2017 (2017-11-21)
AWS Lambda deployement right from IntelliJ (2017-11-22)
Serverless Strangler Pattern on AWS (2017-11-23)
Publishing Messages From a Web App to an AWS SQS Queue via AWS Lamba (2017-11-24)
A Case Study for Serverless Integration: Customizing OpsGenie’s Zendesk Integration with AWS Lambda (2017-11-24)
Cloud Stack Series 3: Serverless (2017-11-24)
How To Add A Contact Form To A Static Website With AWS Lambda (2017-11-24)
Creating Serverless Functions with Python and AWS Lambda (2017-11-25)
Building a serverless web application (2017-11-25)
The Promise of AWS Lambda (2017-11-25)
Serving TensorFlow Models. Serverless (2017-11-26)
Going Serverless with AWS — Serverless User Authentication — Part 3 (2017-11-26)
Breaking down the monolith with AWS Step Functions (2017-11-26)
I Present to You FireDeploy (A small Firebase Deployment CLI for Serverless) (2017-11-27)
5 Commands you must learn when building AWS Serverless applications (2017-11-27)
Azure WebJobs vs. Azure Functions (2017-11-27)
The Microservice Dream and Connecting SendGrid Events to Mixpanel with Serverless and AWS Lambda (2017-11-27)
4 Advantages of using Java with AWS Lambda (2017-11-28)
Building a Serverless Data Pipeline (2017-11-28)
Google Cloud Architecture for the Impatient (2017-11-28)
Serverless is bigger than FaaS (2017-11-28)
Building a REST API with Google Cloud Functions (2017-11-29)
Build a “Serverless” Todo List in 5 Minutes with StdLib and MongoDB (2017-11-29)
Going Serverless? Compare Your FaaS Options (2017-11-29)
AWS announces a serverless database service (2017-11-29)
Amazon Web Services Takes on Kubernetes, Offers a Serverless Database Service (2017-11-29)
Thoughts for AWS Reinvent 2017 Part 1— Serverless (will) Rule (2017-11-29)
Amazon Web Services Advances Lambda Serverless with New Capabilities (2017-11-30)
Handling Serverless Function Timeouts (2017-12-01)
What do I do in between re:Invent live streams? Build Lambda functions (2017-12-01)
AWS Tempts Community With Updates to Lambda Serverless Platform (2017-12-01)
Serverless — revolution or another failure (2017-12-01)
TypeScript and Node AWS Lambda with Serverless (2017-12-03)
Deploying OpenFaaS on Kubernetes — AWS (2017-12-03)
Serverless — Host a website using S3, CloudFront and CloudFlare (2017-12-05)
It’s not just about Lambda — it’s about understanding constraints too (2017-12-06)
Amazon’s Serverless Iron Fist (2017-12-06)
Serverless != Effortless (2017-12-06)
Creating an Image thumbnail generator using Vue, AWS, and Serverless (Part 1) — The Setup (2017-12-07)
Creating an Image thumbnail generator using Vue, AWS, and Serverless (Part 2) — The Upload (2017-12-07)
(Server)less is more (2017-12-07)
AWS Serverless Application Model Template for Lambda Function proxied by API Gateway (2017-12-07)
4 Advantages of Using Java With AWS Lambda (2017-12-09)
AWS Lambda Still Towers Over the Competition, but for How Much Longer? (2017-12-09)
FaaS is a rate plan, not a paradigm (2017-12-09)
A Simple, Serverless API using Azure Tables & Functions (2017-12-09)
Serverless: Flask based Online Python/Ruby/JavaScript Compiler & Runner using AWS Lambda (2017-12-09)
Serverless framework with Node JS AWS (2017-12-10)
Deploying Kubernetes On (2017-12-10)
Introduction (2017-12-10)
What exactly is Serverless? (2017-12-10)
What is Serverless? (2017-12-10)
Rest API using AWS Lamda, Serverless and Nodejs (2017-12-10)
Getting Hooked on Xero with AWS Lambda (2017-12-10)
Effortlessly Set Up a Serverless Web App in Minutes — Web to Lambda (2017-12-11)
Managing AWS Lambda Function Concurrency (2017-12-12)
How We Implemented a Fully Serverless Recommender System Using GCP (2017-12-12)
Serverless transaction processing on AWS (2017-12-12)
Going Serverless (2017-12-12)
Using AWS Lambda functions with AWS API Gateway (2017-12-12)
AWS Lambda Reserved Concurrency (2017-12-13)
Javascript and Functional Programming — Pt. 3: Pure Functions (2017-12-13)
There is no serverless “lock in” (2017-12-14)
How I cloned AWS Lambda in a day. (2017-12-14)
Serverless with Firebase and AWS at Serverless Meetup Rotterdam (2017-12-15)
Qubole Offering Apache Spark on AWS Lambda (2017-12-15)
The Capital One Serverless Architecture for Peer (2017-12-15)
Deploy SaaS with AWS Lambda in under 10 minutes (2017-12-16)
Some quick thoughts on blue/green deployment for Lambda with CloudFormation (2017-12-16)
Developers want to code. Hence Serverless. (2017-12-17)
Developers, developers, developers: How 'serverless' crowd dropped ops like it's hot (2017-12-17)
Serverless Website in AWS and its pricing (2017-12-17)
Developers, developers, developers: How 'serverless' crowd dropped ops like it's hot (2017-12-17)
Binaris Wants to Reduce Latency in Serverless Productions (2017-12-18)
Why you should go Serverless (2017-12-18)
Enable canary deployments with Lambda, API Gateway (2017-12-19)
The Top 10 Serverless Links of 2017 ⚡️ (2017-12-19)
Private OpenFaaS in Microsoft Azure (2017-12-19)
Serverless Framework With AWS (2017-12-19)
Serverless Doorbell — Azure Functions and (2017-12-20)
OpenFaaS on DCOS (2017-12-20)
On IKEA, Serverless computing and moving halfway around the world (2017-12-20)
Serverless Doorbell — and Azure Functions (Part 2) (2017-12-20)
Building a community sign (2017-12-20)
Dealing with the AWS Lambda invocation payload limits (2017-12-21)
Serverless is the way to go, and I agree that it will become a “normal” thing. (2017-12-21)
AWS Lambda Cost Optimization (2017-12-22)
Choose the right APIs and apps for serverless infrastructure (2017-12-22)
Serverless Databases a game changer ? (2017-12-25)
Serverless and Bitcoin — creating price watchers dynamically (2017-12-26)
Putting the server back in serverless (2017-12-26)
Building Your Next Serverless Application: The Complete Guide. (2017-12-27)
How going serverless helped us reduce costs by 70% (2017-12-27)
Building a Serverless API in 10 Minutes (2017-12-27)
How Serverless Technologies Impact Kubernetes (2017-12-28)
Understanding Serverless Architecture advantages and limitations (2017-12-30)
Amazon Kinesis Data Analytics can now Output Real (2017-12-30)
Serverless Approximate Nearest Neighbors on AWS Lambda with Annoy and Chalice (2017-12-30)
WebSockets With AWS Lambda (2017-12-30)
How Serverless Computing will Change the World in 2018 (2017-12-31)
How serverless scales an idea to 100K monthly users — at zero cost (2017-12-31)
Yes, Serverless Architecture will change the way of development and usage of IT capabilities… (2017-12-31)
Serverless vs Apex (2018-01-01)
Serverless with AWS Cognito: Facebook login integration (2018-01-01)
How to build a Serverless URL shortener using AWS Lambda and S3 (2018-01-01)
The state of serverless observability — why we built Thundra (2018-01-02)
The Key Challenges Serverless Will Have to Overcome to Succeed in 2018 (2018-01-02)
Building a community sign (2018-01-02)
Claudia 3.0.0: [email protected] and more (2018-01-03)
How Does Docker Fit In A Serverless World? (2018-01-04)
AWS Lambda — use the invocation context to better handle slow HTTP responses (2018-01-04)
Serverless Computing (2018-01-04)
Lambda Monitoring Comes to SignalFx (2018-01-05)
Serverless Service Discovery – Part 1: Get Started (2018-01-06)
Serverless 101: Why It Matters for Data Center Professionals (2018-01-08)
For Performant Serverless Swift actions… (2018-01-08)
Building A “Serverless” API using Firebase Cloud Functions. (2018-01-09)
Serverless Deployment with Clarive (2018-01-09)
Serverless Stack — CI/CD — Blue (2018-01-09)
Serverless Is a Wrong Name. Fight it with FIRE (2018-01-09)
Understanding Serverless Architecture Advantages and Limitations (2018-01-10)
Ballerina Services in Serverless World (2018-01-10)
IBM Delves into Serverless Function Orchestration with the Open Source Composer Tool (2018-01-10)
OpenFaaS on OpenShift (2018-01-10)
Going Serverless for Event Driven Applications: Insights from Adobe I/O’s Sandeep Paliwal (2018-01-11)
OpenWhisk Web Actions (2018-01-12)
Querying RDS MySQL DB With NodeJS Lambda Function (2018-01-12)
Mapping a Google Sheet with Lambda and Mapbox (2018-01-12)
Humanless (2018-01-13)
OpenFaaS on Minikube: Serverless on Kubernetes for Windows 10 (2018-01-13)
Monolith Vs Microservice Vs Serverless — The Real Winner? The Developer (2018-01-13)
Serverless = A s system that still uses a server but you aren’t the owner, if the server fails then… (2018-01-14)
Use Lambda function to read messages from Kinesis stream (2018-01-15)
What is Serverless Architecture? Serverless Architecture Explained (2018-01-17)
Learn how to be production (2018-01-17)
Hosting a Laravel Application on AWS Lamdba (2018-01-17)
Where to Find Security Holes in Serverless Architecture (2018-01-17)
Serverless Golang API with AWS Lambda (2018-01-19)
Webhooks vs. Serverless: I Like Webhooks (2018-01-19)
Kubernetes for Serverless Applications (2018-01-20)
From servers to functions, the serverless story (2018-01-21)
You need to use structured logging with AWS Lambda (2018-01-21)
Container people, let’s talk about serverless (2018-02-01)
Serverless — Beyond the over simplistic todo apps into the world of reality (part 1) (2018-02-02)
Are Serverless Applications Right For Your Business? (2018-02-03)
Performance debugging for serverless functions using the IBM Cloud Shell (2018-02-05)
Serverless Framework: Defining Per (2018-02-06)
Daily DynamoDB Backups With Serverless (2018-02-06)
Slappbooks: Accounting Application on a Serverless Architecture (2018-02-07)
AWS Step Functions. How to process arrays (2018-02-07)
Announcing Serverless DevRel Services (2018-02-07)
Serverless Health Status Dashboard (2018-02-08)
Serverless Application for Anomaly Detection Using Sigma (2018-02-08)
Simple authentication service with AWS Lambda (2018-02-08)
Introduction to Google Cloud Functions! (2018-02-08)
Lambda for Asynchronous Message Processing Through SQS (2018-02-08)
The Curse of Dead Lambda Functions (2018-02-08)
I disagree with your article that scaling is better with single (2018-02-09)
The State of Operations in Serverless (2018-02-09)
Go Serverless with Firebase (2018-02-09)
Serverless CQRS in Azure (2018-02-09)
APIs deployment on serverless frameworks catching on (2018-02-09)
Serverless App: AWS CloudTrail Log Analytics using Amazon Elasticsearch Service (2018-02-12)
How to Extend the Fn Project with new Functionality (2018-02-13)
Serverless, AWS and CI: my new simple personal website (2018-02-13)
Revolutionizing Application Development Using Serverless Architectures (2018-02-13)
How we do Serverless Big Data ETL/OLAP Queries (2018-02-13)
How to Easily Write Your First Serverless Application (2018-02-14)
Serverless Cloud Native Landscape: New from Redpoint Ventures and the Cloud Native Computing… (2018-02-14)
AWS Server (2018-02-14)
Building Single Page App with Azure Functions and improving cold start time (2018-02-14)
Serverless GraphQL Architecture With Graphcool (2018-02-15)
Building Serverless State Machines (2018-02-15)
Express.js and AWS Lambda — a serverless love story (2018-02-15)
Static Websites On AWS S3 Using Serverless Framework — Tutorial (2018-02-15)
OpenFAAS is the one to keep an eye on here. (2018-02-15)
Serverless architectures (2018-02-18)
Almost free server monitoring with AWS Lambda (2018-02-18)
Easy Database Setup the Serverless Way (2018-02-19)
How Can Serverless Computing Benefit Your Startup? (2018-02-19)
Serverless Revolution: the Good, the Bad and the Ugly (2018-02-20)
Running a scalable & reliable GraphQL endpoint with Serverless (2018-02-20)
AWS Serverless for a global web app (2018-02-21)
Datadog is in the AWS Serverless Application Repository (2018-02-21)
New Relic Joins the AWS Serverless Application Repository (2018-02-21)
The AWS Serverless Application Repository Launches — with an IOpipe app! (2018-02-21)
Going Serverless with Amazon Web Services (AWS) — The Traditional Approach (2018-02-21)
Data Flows in Serverless Cloud (2018-02-22)
Why deploying APIs on serverless frameworks spurs innovation (2018-02-22)
Inside a Lambda Runtime: A Peek into the Serverless Lair (2018-02-22)
Serverless Architecture and Web Scraping? (2018-02-22)
Going Serverless: From Common LISP and CGI to AWS Lambda and API Gateway (2018-02-22)
Serverless application with CI/CD based on AWS and Bitbucket Pipelines (2018-02-22)
Server (2018-02-23)
AWS Getting Started with API Gateway, Lambda & DynamoDB for an basic REST API (2018-02-23)
Continuous Deployment with Serverless and CircleCI (2018-02-24)
Building Serverless Microservices on AWS (2018-02-25)
Going Serverless with Amazon Web Services (AWS) (2018-02-26)
How we built (2018-02-26)
Implementing the Strangler Pattern with Serverless (2018-02-28)
Serverless Stack Experiences (2018-03-01)
VMs, Containers or Serverless? (2018-03-01)
Go + Lambda = ⚡️ Building a Serverless Go API in 3 Hours (2018-03-01)
Building Serverless API’s with TypeScript and Azure Function Proxies (2018-03-01)
How to Build a Serverless Slack API with Django and Zappa (2018-03-04)
OpenFaaS (2018-03-04)
Serverless Application with Flutter & Lambda (2018-03-05)
Twitter Bot Using Amazon Translate (2018-03-05)
Serverless: Creating new opportunities for developers (2018-03-05)
LunchBadger: Microservices, Serverless on Kubernetes (2018-03-06)
Improve Your AWS Lambda Development With Sigma (2018-03-06)
6 Priorities for Ops in a ‘Serverless’ World (2018-03-06)
A Practical Guide to Getting Started With AWS Lambda Functions Using Go (2018-03-06)
Introduction to Serverless Applications (2018-03-06)
Going Serverless with Amazon Web Services (AWS) — The Modern Approach (2018-03-06)
Released: GoServerless (2018-03-07)
The world's first Instagram only, serverless ecommerce store. (2018-03-08)
Prototyping Serverless Applications (2018-03-08)
This is why you should consider using aws (2018-03-08)
Azure Serverless Computing — FREE e (2018-03-09)
How to deploy Lambda function with CloudFormation? (2018-03-10)
What is “Serverless Computing”? (2018-03-12)
Serverless Ops: (2018-03-12)
Serverless — Building a crypto wallet balance API to use with google spreadsheets (part 2) (2018-03-12)
Serverless Computing (2018-03-13)
AWS Tutorial: How to Build a Serverless Slack Chatbot (2018-03-13)
Under The Hood of Effectiv (2018-03-13)
Designing an event (2018-03-13)
Examining the AWS Serverless Application Repository (2018-03-14)
Why AWS Lambda and .zip is a recipe for serverless success (2018-03-15)
Serverless Application with Google Flutter and Lambda (2018-03-16)
Hello Cloud : a Serverless journey (2018-03-16)
Running Go AWS Lambdas locally with SLS framework and SAM (2018-03-17)
Integrating S3 with Lambda (plus some use cases) (2018-03-18)
Operating Your Serverless API in Production at Scale (2018-03-18)
Building a Serverless Vuejs App with Firebase Firestore (2018-03-19)
Running a scalable & reliable GraphQL endpoint with Serverless (2018-03-22)
Why Serverless? Why Now? (2018-03-23)
Running around the block: a beginner meets AWS Lambda (2018-03-24)
Deploy a serverless flask application on AWS Lambda (2018-03-24)
Serverless and Flogo: A Perfect Match (2018-03-24)
How we migrated our infrastructure to “serverless” (2018-03-25)
Serverless ETL using AWS Lambda (2018-03-25)
Building Lambdas: Terraform vs Serverless. (2018-03-25)
Serverless doesn’t have to be an infuriating black box (2018-03-26)
Serverless Image Preprocessing using AWS Lambda (2018-03-27)
Welcome to Quebic (2018-03-27)
Sending emails with attachments with AWS Lambda and Node.js (2018-03-27)
Developing Polyglot Serverless Applications (2018-03-27)
Lessons learned in serverless (2018-03-28)
Applying ROP Chaining Concepts to Serverless Functions (2018-03-28)
From Express.js to AWS Lambda: Migrating existing Node.js applications to serverless (2018-03-28)
Why All The Monolithic Serverless API Hate? (2018-03-29)
How to call multiple Serverless micro (2018-03-29)
AWS DynamoDB for Serverless Microservices (2018-03-30)
Intro to Go Functions (2018-03-30)
How we migrated our infrastructure to “serverless” (2018-03-30)
Serverless podcast RSS feed parser (2018-03-30)
Getting started with AWS Lambda — Part 1 (2018-04-02)
AWS Serverless MicroServices Composition (2018-04-04)
Building single source of truth using Serverless and NoSQL (2018-04-05)
AWS Lambda: Your Quick Start Guide to Going Serverless (2018-04-06)
Azure Functions step 1: start developing Serverless functions locally (2018-04-07)
Cloudflare Workers….where’s the origin? (2018-04-07)
Developing Applications with Serverless Architecture (2018-04-09)
Spreading the Word on Serverless (2018-04-09)
Dispatch + Services (2018-04-11)
Lessons Learned using AWS Lambda as Remediation System (2018-04-11)
To Do Serverless Right, You Need A New IAM Approach (2018-04-12)
Serverless and Kubernetes Demos (2018-04-12)
AWS Lambda: Easily process millions of files at low cost. (2018-04-12)
Slowly Baking Bread with AWS Step Functions (2018-04-12)
Deploy your Flask API to any Serverless Cloud Platform using this Simple Pattern (2018-04-12)
Exploring Dask and Distributed on AWS Lambda (2018-04-13)
Create a personalised news feed with AWS Lambda, Telegram and NewsAPI (2018-04-13)
Dealing with cold starts in AWS Lambda (2018-04-13)
Serverless application with AWS Lambda and Kotlin. Part 1 (2018-04-14)
Node (2018-04-14)
Aws vs Google vs Microsoft: How cloud giants are battling it out in the serverless arena (2018-04-15)
Fantastic Serverless security risks, and where to find them (2018-04-17) Migrating to Node 8 (2018-04-20)
Serverless (2018-04-20)
The Holo vision: Serverless 2.0 (2018-04-20)
Error handling with API Gateway and Go Lambda functions (2018-04-24)
Google Cloud Functions Tutorial : What is Google Cloud Functions? (2018-04-25)
9 Serverless Security Best Practices (2018-04-27)
Documenting Serverless Architectures (2018-04-29)
AWS Lambda — Serverless Superhero (2018-04-30)
Infrastructure Cost Optimization with Lambda (2018-05-01)
A crash course on securing Serverless APIs with JSON web tokens (2018-05-03)
Introduction to Serverless Computing (2018-05-03)
Serverless “Hello World” in AWS (2018-05-05)
The monolith, microservices and serverless computing: pros and cons (2018-05-11)
auto (2018-05-13)
Gzip/deflate content from AWS API Gateway using Serverless (2018-05-14)
AWS introduces 1 (2018-05-14)
The Future of Ops in a Serverless World (2018-05-16)
Red Hat Summit: Functions as a Service with OpenWhisk and OpenShift (2018-05-16)
Lessons in Serverless & AWS (2018-05-19)
Weekly check for Lambda functions (2018-05-20)
This is Serverless (2018-05-20)
Serverless Security Scorecard (2018-05-24)
How to Monitor AWS Lambda with Zero Overhead (2018-05-25)
Apollo Server + Serverless = Graphql Bliss! (2018-05-25)
Serverless Architecture (2018-05-25)
Serverless — Should it be an afterthought? (2018-05-27)
Everything you need to know about cold starts in AWS Lambda (2018-06-01)
Serverless Technology: The Future of Cloud Technology (2018-06-01)
Still using Microservices, why not jump to the next big thing Serverless Microservices? (2018-06-02)
Getting Started Serverless for Cloud Functions (2018-06-05)
Building Serverless Applications With an API (2018-06-05)
Let’s Go Serverless!! (2018-06-05)
The Serverless Revolution (2018-06-05)
Serverless and NoOps at Volta (2018-06-05)
Self Healing Serverless Applications (2018-06-07)
Serverless, Containers and Application Operations (2018-06-07)
Building REST services with Serverless framework, in Node.js, AWS Lambda and DynamoDB (2018-06-08)
Creating a Lambda Web Service (2018-06-08)
Architect, The Killer Serverless Framework (2018-06-11)
The Benefits of Serverless Computing and its Impact on DevOps (2018-06-15)
Self Healing Serverless Applications (2018-06-18)
Serverless — Cloud Custodian setup on AWS Lambda (2018-06-24)
AWS Lambda with Spring Boot (2018-06-25)
How to write Alexa skill data to DynamoDB with AWS Lambda (2018-06-26)
Serverless GraphQL with FREE CDN & in (2018-06-27)
Developing Protected Serverless Web Applications With IBM Cloud Functions (2018-06-27)
Serverless/FaaS (eg AWS Lambda) vs PaaS (eg Azure Web Apps) (2018-06-27)
The evolution of a JavaScript function (2018-06-27)
Building a “Serverless” RESTful API with Cloud Functions, Firestore and Express (2018-06-27)
Event (2018-06-28)
DynamoDB Injection (2018-06-28)
Building reliable workflows using Serverless (2018-06-28)
Tracing Lambda with X (2018-06-28)
Microsoft Azure’s Durable Functions for Serverless JavaScript (2018-06-28)
Delivering a Serverless API in 10 minutes using Workers (2018-06-28)
Leveraging Lambda for Serverless Slack Apps (2018-06-28)
SQS as an event source to trigger Lambda (2018-06-28)
Openwhisk web actions for API backends (2018-06-28)
Using Fractal as Your OpenWhisk API's View Layer (2018-06-29)
Understanding serverless architecture capabilities available on Azure (2018-06-29)
Serverless application architecture, patterns, and implementation (2018-07-03)
Organize your Lambda functions into separate services (2018-07-03)
Self Healing Serverless Applications (2018-07-04)
Part 1: Serverless Web app using AWS Amplify and Angular (2018-07-06)
Meet Mike Lee Williams: Serverless and its Relevance for Data Scientists (2018-07-10)
Podcast: What is Serverless (2018-07-10)
The 10 commandments of serverless (2018-07-11)
Implementing SQS in Serverless….the right way (2018-07-11)
Scrontab: The Serverless Crontab (2018-07-12)
A crash course on Serverless APIs with Express and MongoDB (2018-07-12)
A Serverless Streaming API Prototype Using AWS Lambda (2018-07-12)
Deploying Drift Apps on AWS using AWS Lambda and API Gateway (2018-07-12)
Understanding AWS Cognito User and Identity Pools for Serverless Apps (2018-07-12)
Build and Deploy a Serverless Node.js App powered by Cosmic JS (2018-07-12)
Disaster Recovery in a Serverless World — Part 1 (2018-07-12)
Serverless Computing : Introduction (2018-07-12)
Serverless Case Study — Netflix (2018-07-13)
Serverless Security Risks Laid Bare (2018-07-13)
An Experiment in Serverless (2018-07-13)
The Serverless Framework Landscape (2018-07-13)
Navigate your AWS Lambda Logs from Amazon API Gateway Response Headers (2018-07-13)
The Serverless Contract (2018-07-13)
AWS Serverless — SNS Notifications to Slack without Lambda via API Gateway (2018-07-14)
Demystifying the term Serverless (2018-07-14)
Building a Start (2018-07-14)
Serverless plays Rock (2018-07-15)
Migrating to Serverless in an Production Setting (2018-07-16)
Should I use a single, monolithic Lambda function or multiple Lambda functions with API Gateway? (2018-07-16)
Getting a Handle on Spiraling AWS Lambda Cost in Seconds (2018-07-18)
Cutting Through the Hype: When Serverless Works and When It Doesn’t (2018-07-18)
Building a serverless contact form with AWS Lambda and AWS SES (2018-07-18)
Serverless PHP (2018-07-18)
Build a Realtime Serverless GraphQL API with Websockets on AWS (2018-07-19)
No more secrets with your AWS Lambda invocations (2018-07-20)
Serverless testing from the trenches (2018-07-22)
High Availability — When (Server)Less Is More (2018-07-22)
Serverless Application on Google Cloud (2018-07-22)
How to deploy a Node.js application to AWS Lambda using Serverless (2018-07-25)
With Knative, Google Brings Multicloud Serverless to the Enterprise (2018-07-25)
How to Use Feature Flags With Serverless Architecture (2018-07-27)
Serverless Testing in Production (2018-07-30)
Serverless, Inc. lands $10M Series A to build serverless developers platform (2018-07-30)
Go Serverless in AWS (2018-07-30)
Serverless, Inc. lands $10M Series A to build serverless developers platform (2018-07-30)
From Monolithic to Serverless — The 3 W’s (Why, What and When) (2018-08-01)
From Instances to Functions: Evolution of AWS Compute Resources (2018-08-01)
Add It Up: Container Deployment Still Outpaces ‘Serverless’ (2018-08-02)
Discussing Serverless with Stackery and Google (2018-08-02)
My Roller Coaster Journey in Learning Serverless (2018-08-02)
You don’t need frameworks for a serverless API in Java (2018-08-03)
From Agile to Serverless (2018-08-03)
How to do serverless machine learning with scikit (2018-08-03)
Updating GuardDuty Threatlists with Serverless (2018-08-03)
The New Stack Context: Istio 1.0 and ServerlessConf (2018-08-03)
Start Your Serverless Journey with Zoho Creator (2018-08-04)
AWS Lambda (2018-08-04)
Nano Services based ServerLess Architecture using AWS (2018-08-04)
Building a Serverless CI/CD Pipeline with Jenkins (2018-08-05)
Controlling concurrency of AWS Lambda (2018-08-07)
Aurora Serverless MySQL Generally Available (2018-08-09)
Amazon Aurora Serverless  (2018-08-10)
Amazon Aurora Serverless now generally available (2018-08-10)
Introduction to Azure Functions (2018-08-12)
Serverless are Everywhere Now for Me. (2018-08-12)
Templatizing AWS Serverless Functions Using OpenAPI (2018-08-13)
Aurora Serverless for MySQL 5.6 — Generally Available (2018-08-16)
Outreachy internship with Mozilla: AWS Lambda with Serverless (2018-08-16)
Serverless and Flogo — Part 2 (2018-08-16)
Anatomy of a Serverless Application (2018-08-18)
Writing an Event (2018-08-18)
Create a Serverless GraphQL server using Express, Apollo Server and AWS Lambda (2018-08-19)
Serverless Monitoring in the Age of Infrastructure (2018-08-21)
Azure Functions + Docker Container (2018-08-22)
Serverless Computing: AWS Lambda (2018-08-22)
Serverless Pricing and Costs: AWS Lambda and [email protected] (2018-08-22)
Answering the Biggest AWS Lambda Questions (2018-08-22)
The real benefits and drawbacks of Cloud Functions ⚡️ (2018-08-23)
Automating CI/CD workflow for serverless apps with CircleCI (2018-08-23)
Why Even Bother with Serverless? (2018-08-24)
Serverless vs. Containers (2018-08-24)
Swagger, API Gateway, Lambda Setup Using AWS Serverless Application Model (2018-08-24)
Create DynamoDB — AWS Serverless to DynamoDB (2018-08-25)
Statistics support for OpenWhisk Serverless Platform using Prometheus and Grafana (2018-08-26)
Create Lambda and API Gateway (Nodejs) — AWS Serverless to DynamoDB (2018-08-26)
Is FaaS Ready For Enterprise? (2018-08-26)
Serverless Databases: The Future of Event (2018-08-26)
7 New things in AWS Amplify (2018-08-26)
Serverless Monitoring, Streamlined! (2018-08-27)
Introducing the New AWS Amplify CLI Toolchain (2018-08-27)
Generating Least Privileged IAM Roles for AWS Lambda Functions — The Easy Way (2018-08-27)
Serverless in Production: Performance and Scale (2018-08-28)
Unconventional Lambdas (2018-08-28)
Five Serverless Aspects to Keep in Mind (2018-08-29)
Extend your services with Serverless computing (2018-08-29)
How to Build a Serverless App using the AWS Console (2018-08-29)
5 common mistakes deploying Lambda functions (2018-08-29)
Lessons Learned Building a Large Serverless Project on AWS (2018-08-29)

If you think there is a link I should have listed here feel free to tweet it at me, or submit as a Github issue. Even though I do this full time, I'm still a one person show, and I miss quite a bit, and depend on my network to help me know what is going on.