Why do I need to pick a specific runtime version like nodejs20.x instead of just "nodejs"?

Lambda runtimes are versioned and each one is a distinct execution environment with its own language version and available libraries; "nodejs" alone isn't a valid Runtime value. The four offered here (nodejs20.x, python3.12, go1.x, java21) are commonly used current or recent runtimes across their language families.

What happens if I enable VPC config?

Adding a VpcConfig block (SubnetIds and SecurityGroupIds) attaches the function's network interfaces to your VPC, letting it reach resources like an RDS instance or ElastiCache cluster that aren't publicly reachable. It also means the function needs NAT/VPC endpoint access to reach the public internet or other AWS APIs.

What's a dead-letter queue used for here?

The DeadLetterConfig's TargetArn (an SQS queue or SNS topic ARN) is where Lambda sends the event payload if an asynchronous invocation fails all its retries, so you don't silently lose failed events. It only applies to asynchronous invocations; synchronous callers instead get the error returned directly.

AWS Lambda Config Generator - Runtime, VPC & DLQ Template

Q: Does this tool actually create or update a Lambda function?

No, it only generates the configuration JSON/YAML client-side. You still need to pass it to `aws lambda create-function`/`update-function-configuration`, a CloudFormation `AWS::Lambda::Function` resource, or your IaC tool of choice to actually apply it.

Overview

Introduction

A Lambda function's configuration touches several unrelated concerns at once: the runtime and handler, memory and timeout limits, environment variables, optional VPC networking, and an optional dead-letter target, each with its own nested JSON shape in the actual API.

This tool generates that configuration in one pass, matching the field names and nesting the Lambda `CreateFunction`/`UpdateFunctionConfiguration` APIs actually expect, as either JSON or YAML.

What Is AWS Lambda Config Generator?

A generator for a Lambda function's configuration template: Handler, Runtime, MemorySize, Timeout, an optional Environment.Variables map, an optional VpcConfig (SubnetIds/SecurityGroupIds), and an optional DeadLetterConfig.TargetArn.

Four runtimes are directly selectable (nodejs20.x, python3.12, go1.x, java21), covering current versions across JavaScript, Python, Go, and Java.

How AWS Lambda Config Generator Works

MemorySize and Timeout are validated against Lambda's actual accepted ranges (128-10240 MB, 1-900 seconds) before the template is built, so the output always reflects values Lambda will accept.

Environment variable lines (`KEY=VALUE`) are parsed into an `Environment.Variables` object; VPC subnet and security group ID lists are parsed the same way into a `VpcConfig` block, only included when VPC is toggled on and both lists are non-empty.

A dead-letter queue ARN, if provided, is wrapped as `DeadLetterConfig.TargetArn`, matching the shape Lambda expects for both SQS queue and SNS topic targets.

When To Use AWS Lambda Config Generator

Use it when defining a new Lambda function's configuration for a deploy script, CloudFormation template, or Terraform `aws_lambda_function` resource, and want the field names and nesting guaranteed correct.

It's also useful for quickly drafting a VPC-attached function's networking config or wiring up a dead-letter queue without looking up the exact JSON key names each time.

Often used alongside ECS Task Definition Generator and AWS IAM Policy Generator.

Features

Advantages

Validates MemorySize and Timeout against Lambda's real accepted ranges before generating output.
Produces the correct nested shape for Environment, VpcConfig, and DeadLetterConfig, all common sources of small JSON-structure mistakes.
Supports both JSON and YAML output from the same fields.

Limitations

Doesn't cover every Lambda configuration option (layers, reserved concurrency, X-Ray tracing, ephemeral storage size); only the fields listed above.
Doesn't validate that subnet IDs, security group IDs, or the DLQ ARN actually exist in your account.

Examples

Node.js function with environment variables, no VPC

Input

handler: index.handler, runtime: nodejs20.x, memorySize: 256, timeout: 10, environmentVars: NODE_ENV=production

Output

{
  "Handler": "index.handler",
  "Runtime": "nodejs20.x",
  "MemorySize": 256,
  "Timeout": 10,
  "Environment": {
    "Variables": {
      "NODE_ENV": "production"
    }
  }
}

VpcConfig and DeadLetterConfig are omitted entirely since VPC wasn't enabled and no DLQ ARN was provided.

Best Practices & Notes

Best Practices

Set Timeout close to your function's real expected duration, not the 900-second maximum by default, since a stuck invocation otherwise runs (and bills) far longer than necessary.
Only enable VpcConfig when the function genuinely needs to reach VPC-only resources, it adds cold-start latency and requires NAT/VPC-endpoint access for any external calls.
Wire up a dead-letter queue for any function invoked asynchronously (S3 events, SNS, EventBridge) so failed events are recoverable instead of silently dropped.

Developer Notes

The configuration object mirrors the Lambda `CreateFunction`/`UpdateFunctionConfiguration` API's field names and nesting exactly (`Environment.Variables`, `VpcConfig.SubnetIds`/`SecurityGroupIds`, `DeadLetterConfig.TargetArn`) so it can be used close to as-is in an SDK call or IaC resource, subject to camelCase/PascalCase conventions your specific tool expects. Environment variable and ID-list parsing both split on newlines (and commas for ID lists), trimming whitespace, with malformed or empty lines silently skipped rather than erroring.

AWS Lambda Config Generator Use Cases

Drafting a new Lambda function's configuration before writing the deploy script or IaC resource
Wiring up VPC access for a function that needs to reach an RDS instance or internal service
Adding dead-letter queue handling to an asynchronously-invoked function

Common Mistakes

Enabling VPC config without also ensuring NAT gateway or VPC endpoint access, which silently breaks the function's ability to call external APIs or other AWS services.
Setting Timeout to the 900-second maximum out of caution, which can hide performance problems and increase costs on invocations that hang rather than fail fast.

Tips

Follow up with the IAM Policy Generator to build the execution role policy this function's role will need for whatever AWS services it calls.

AWS Lambda Config Generator