The Complete Guide to Build Serverless Applications on AWS

Design a serverless AWS-based architecture for the National Fuel Path app, enabling registration, OTP verification, and QR code issuance for fuel access.

Design a scalable serverless AWS architecture with passwordless OTP authentication, store user and vehicle data, verify details via external systems, deliver QR codes via SMS securely and asynchronously.

Design a serverless first frontend architecture using S3 static hosting and CloudFront caching, with Amazon Incognito passwordless authentication via OTP and SNS for SMS delivery, plus Amplify token management.

Verify OTP and collect user details, then trigger a register flow through API gateway and a user register Lambda. Store the data in a DynamoDB user table for next steps.

Evaluate the user registration architecture across scalability, cost, security, and complexity using serverless services. Highlight security controls like CloudFront with origin access identity and Cognito tokens, and reserve Lambda concurrency.

Decouple vehicle registration using api gateway, incognito user pool, event bridge, and simple queue service for real-time pub/sub routing.

Explore how EventBridge enables easy extension of serverless applications by ingesting events, using rules to filter corporate events, and routing them to the appropriate external systems.

Discover a scalable serverless architecture using event bridge, lambda, and queue-based controls to throttle concurrent vehicle registrations, with asynchronous flow, dead letter queue, and sms-enabled qr code delivery.

Orchestrate vehicle registration and QR code generation with step function express workflows, integrating DynamoDB, S3, and EventBridge; compare orchestration and choreography and enable observability with X-Ray.

Master circuit breaker patterns to gracefully handle offline downstream services, using Lambda with a heartbeat table, dead-letter queue, and time-to-live based recovery, supported by Cockatiel for Node.js.

Discover how to implement idempotency in serverless AWS workloads using DynamoDB conditional writes, Lambda Power Tools, and idempotency keys to prevent duplicate records or charges in Express Workflows.

Explore core serverless services on AWS, including Lambda, API Gateway, DynamoDB, IAM, and CloudWatch, and learn how they orchestrate event-driven, scalable applications.

Explore AWS Lambda as the core serverless, event-driven engine. Trigger it by events like HTTP, S3, and DynamoDB streams to fetch weather data and create thumbnails.

Learn to access AWS Lambda from the console, create functions from scratch or via blueprint or container image, select runtime, set triggers, and note infrastructure as code with serverless framework.

Explore amazon api gateway, a fully managed restful api service for web, mobile, and private networks, with caching, authorization, lambda and dynamo db integrations.

Design DynamoDB tables with appropriate keys, indexes, and data modeling to guarantee latency and enable efficient queries. Enable streams, encryption, PITR, and global tables for event-driven, multi-region serverless apps.

Discover how to model data in DynamoDB with a five-step NoSQL approach, identifying access patterns, choosing hash and range keys, and using secondary indexes for fast, scalable queries.

Define and manage access with IAM in AWS by configuring users, groups, and roles, attaching policies to control access to resources like S3 and DynamoDB, using roles for temporary credentials.

Explore Amazon CloudWatch as a centralized logging and observability service that collects logs from cloud resources, applications, and on-premises servers, enabling custom metrics, alarms, and automated responses with AWS Lambda.

Discover how AWS CloudWatch manages logs with log groups and streams and sets retention policies. Learn to create metric and subscription filters, trigger alarms, and integrate with Lambda for observability.

Build a serverless rest api from scratch using the serverless framework and AWS serverless services, with a beginner-friendly overview of AWS serverless api design.

Explore the architecture of a serverless note-taking app built with api gateway, lambda, and dynamodb, using infrastructure as code with the serverless framework, rest api, and crud operations.

Install Visual Studio Code and Node.js 20, install the serverless cli version 3.38, and use the serverless framework to create a Node.js project, configure serverless.yml, and define AWS lambda functions.

Configure AWS credentials by creating an IAM user with administrator access, generate an access key and secret, and set up credentials locally using npm run sls config credentials.

Deploy a serverless application on AWS using the serverless framework to expose a get endpoint via API gateway that triggers a Lambda function and returns its message.

Cover the remaining crud endpoints for nodes—delete node, get all nodes, and get node by id—configured with serverless, lambda functions, and api gateway.

Explore API gateway routes for node CRUD operations to Lambda functions via proxy integration, reviewing the dev stage in us east 2 and the get all nodes flow.

Create a DynamoDB table named notes with a hash key notes id using CloudFormation in serverless.yml, set pay-per-request billing, and enable Lambda access via AWS SDK v3.

Connect DynamoDB to Lambda using AWS SDK for JavaScript v3, utilize the document client to simplify marshalling, and install the library and client as dev dependencies for local exploration.

Describe implementing create note functionality using a put command, parsing event body, generating a uuid, and storing in DynamoDB with a conditional expression and iam permissions.

Implement an update node function for DynamoDB, granting update item permission, and use an update expression with attribute names/values and attribute_exists to return 200 on success or 500 on error.

Learn to replace hardcoded notes table names with environment variables in serverless.yml at the provider level, reference them in lambdas via process.env and href, then redeploy and test the endpoints.

Implement delete and get operations for notes in a serverless AWS app, using DynamoDB get and delete commands with an existence check and robust error handling.

Learn to implement a get all notes endpoint by using DynamoDB scan to return all items from the notes table, with proper permissions and testing.

Explore how to build a REST API from scratch using the serverless framework and serverless services on AWS, for developers new to serverless application development.

Explore the architecture of a serverless REST API on AWS using API Gateway, Lambda, and DynamoDB to create, read, update, and delete notes, provisioned with Serverless Framework and secure permissions.

Set up Visual Studio Code as your code editor, then install the serverless framework CLI globally with npm. Use serverless framework v2 to build serverless applications on AWS.

Create the first AWS Lambda function and connect it to API Gateway to expose a post /notes endpoint, deploy with Serverless, and test using Postman.

Create and deploy lambda functions to provide CRUD endpoints for notes, including update, delete, and get all notes, using API gateway and dynamic path parameters.

Explore how API Gateway endpoints for creating, reading, updating, and deleting nodes trigger Lambda functions via proxy integration, returning responses in a serverless AWS workflow.

Create a DynamoDB table with CloudFormation in a serverless framework, configuring attribute definitions, key schema, and on-demand billing, then deploy and connect it to a Lambda function using the SDK.

Implement a CreateNote lambda using the DynamoDB document client to put items into the noughts table via API gateway, and include error handling and permission setup.

Learn how to grant per-function DynamoDB put item permissions using an IAM role for the function, leveraging a serverless plugin and CloudFormation intrinsic functions to reference the table.

Implement the update note lambda to update a DynamoDB item's title and body. Use an environment variable for the table name and an update expression with attribute names and values.

Implement a delete note lambda function with DynamoDB delete permission, configure the table name via environment variable, and verify deletion via Postman using a conditional delete.

Implement a get notes Lambda function that scans a DynamoDB table, returns all notes via a document client, and includes deployment and testing with Postman.

Explore optimizing serverless lambdas by preventing event loop waits. Set context.callbackWaitsForEmptyEventLoop to false so callbacks return immediately, then apply to create, update, delete, and get functions and deploy.

Enable http keep-alive to reuse connections in lambda invocations. Configure an environment variable to enable reuse, reducing latency when lambda functions call the AWS SDK and DynamoDB.

deploy a Node.js notes api with the serverless framework, using an IAM user, lambda functions for create, update, delete, and get notes, and a DynamoDB table via CloudFormation.

Learn how to secure a REST API with API key access control in AWS API Gateway by creating a usage plan, generating API keys, and enforcing key requirements on methods.

Learn to configure API key access with the serverless framework, replacing console-based setup, by defining usage plans, API keys, and throttling in serverless.yml for AWS API gateway.

Define and deploy a custom AWS Lambda authorizer in serverless framework, implement token-based access control, generate and attach an IAM policy to API Gateway endpoints, and test with usage plans.

Explore how a Lambda authorizer controls access to API Gateway endpoints, inspect policy documents and authorizer context in CloudWatch logs, and share context across downstream Lambda functions.

Create a Cognito user pool in the AWS console, enable username sign-in and self-signup, configure email verification, and set up a hosted UI with an implicit grant flow for tokens.

Configure Amazon API Gateway with a Cognito user pool authorizer to authorize requests via ID tokens from a user pool, test with Postman, deploy, and view claims in CloudWatch logs.

Explore how Cognito user pool authorizers validate access by user pool membership alone, not IAM roles or groups, and how to enforce denies with API gateway using optional Lambda authorizers.

Automate creation of a Cognito user pool, its client, and domain with CloudFormation via the Serverless Framework, using infrastructure as code for production-ready authentication.

Replace hardcoded values with environment variables in your serverless AWS app by using CloudFormation intrinsic functions to fetch the user pool attributes and pass them to Lambda handlers.

Fix a deployment issue in a serverless framework by configuring a user pool authorizer type and using an intrinsic reference, then redeploy to a new stage and verify API authorization.

Test your serverless api by configuring Cognito user pools, creating a user, obtaining the id token, and updating the web client with implicit flow and callback settings.

Learn how to segregate resources into different environments—development, testing, and production—by isolating databases and maintaining separate production and test tables to enable effective serverless app development on AWS.

This lecture demonstrates configuring multi-environment deployments with the serverless framework by using a command-line stage parameter, default values, and dynamic resource naming.

Create a new demo environment by deploying with the stage demo flag, redeploy the code, and verify demo nodes, user pool, Dynamo TV table, API gateway, and lambda functions.

Test the serverless environment by creating a user, obtaining authorization tokens, updating api gateway endpoints, and performing authenticated note creation and retrieval with DynamoDB.

Compare continuous integration, continuous delivery, and continuous deployment; learn how build, test, and package steps transition with a manual review quality gate in a mature deployment pipeline.

Create a buildspec.yml in a build config folder to define installation, pre-build, build, and post-build phases, set node version 14, install serverless, npm dependencies, run tests, and package artifacts.

Troubleshoot and optimize a pipeline by committing config, triggering builds, fixing missing files and node runtime, updating the build image, and granting parameter store access, ending with a successful run.

Find serverless build artifacts in the S3 bucket via CodePipeline history for the Nord Do pipeline, including build and source artifacts, and download the source artifact to view GitLab snapshot.

Diagnose the deployment failure by inspecting the build tail for the forbidden Cerberus error during serverless deploy, then grant administrator access to the codebuild service role and rerun.

Explore using GitHub actions to deploy serverless applications to AWS, triggering dev deployments on pull requests and prod deployments on merges, with YAML workflows and CDK pipelines.

Discover how to use GitHub Actions to build a simple seed continuous delivery pipeline for code on GitHub, with build specs in code and event-driven triggers, plus Serverless Framework integration.

Explore how GitHub actions automate your workflows, run in response to events, and deploy serverless apps to AWS Lambda or containers, with multi-runtime and language support.

Demonstrates deploying a production serverless workflow on AWS by installing the serverless plugin in GitHub Actions, configuring a production stage, and verifying API Gateway, Lambda endpoints, and DynamoDB resources.

Explore the test honeycomb strategy for serverless microservices, prioritizing integration and acceptance tests over unit tests, and apply it to API gateway, Lambda functions, and DynamoDB.

Configure and test the AWS Cognito Admin API by initializing environment variables, creating an authenticated user in the user pool, and obtaining an ID token to drive admin flows.

Enable the Cognito admin outflow by updating the user pool client with explicit outflows, enabling password-based login and token issuance via SRP.

Create a test to add a new node with id 1000, title and description, using an id token, via the nodes post endpoint, and verify a 201 response.

Implement update and delete note tests for a serverless AWS app, using put requests, note ids, and body data, and validate results with npm test and DynamoDB checks.

Fix the caching issue by reworking the lambda authorizer policy to split API gateway resources and use wildcards, reducing latency while ensuring create, update, and delete notes tests pass.