AWS Lambda’s INIT billing update: What’s changing and why it matters for your cloud costs

Starting on Aug. 1, 2025, AWS will bill for the initialization (INIT) phase of Lambda functions, bringing a key change to how you are charged for serverless workloads. This billing update will impact functions using managed runtimes with ZIP archive packaging, which previously excluded the INIT phase from the billed duration.

For teams that rely heavily on AWS Lambda, this is a small but significant change. The INIT phase, while short, could introduce costs that were previously invisible. If you’re not actively monitoring your Lambda cold starts or tracking per-function cost trends, this update might catch you off guard.

This blog will help you understand what exactly is changing, how it could impact your cloud bill, and why now is the right time to start using a dedicated cloud cost management tool.

Understanding the INIT phase

A Lambda function’s execution has three phases: INIT, INVOKE, and SHUTDOWN. INIT is triggered when the function runs in a new environment—a situation commonly known as a cold start. During this phase, AWS:

  • Downloads your function code from an internal Simple Storage Service bucket or container registry.

  • Configures the runtime environment (the memory, variables, and dependencies).

  • Runs the static INIT code.

  • Sets up any required extensions.

This phase can take anywhere from a few milliseconds to several seconds depending on the package size, language, and logic included. It happens less frequently than the INVOKE phase, but its duration is noticeable—and soon, it will also be billable.

Previously, the INIT time was not billed for ZIP-packaged functions using managed runtimes. Starting in August, this will change. The billed duration will include the INIT time for all functions, regardless of the packaging method or runtime.

How will this impact your Lambda costs?

For many users, this change will have a very small effect; cold starts typically occur in less than 1% of total invocations. However, for high-throughput systems, large environments, or poorly optimized functions, even rare cold starts could accrue meaningful costs.

Suppose you are running a function that runs with 1GB of memory and takes 300ms to execute. If the INIT phase adds another 100ms during a cold start, this time will soon become billable. Multiply that across thousands of invocations in a day, and your bill will go up, especially in regions with higher Lambda pricing.

The update will also affect how the duration is logged. Starting on August 1, CloudWatch logs will show an increased Billed Duration value, which will include the INIT time. That’s a crucial signal for teams to monitor and analyze function behavior.

Why visibility is key and where CloudSpend fits in

You can’t manage what you can’t see. As AWS gets more granular with billing, organizations need more granular cost tracking.

ManageEngine CloudSpend can help you:

  • Break down Lambda costs by the region, account, or function.

  • Isolate functions with frequent or costly cold starts.

  • Identify unusually high INIT durations across environments.

  • Forecast cost increases due to changes in AWS billing models.

  • Set budgets and alerts before costs get out of hand.

This visibility allows you to plan, optimize function design, and avoid unexpected budget overruns.

What you should do to reduce INIT costs

AWS provides several ways to reduce cold start times—and by extension, INIT billing:

  • Reduce the function package size: Remove unnecessary dependencies, minimize the code, and use tools like esbuild to bundle efficiently. Smaller packages load faster and reduce the INIT duration.

  • Shift logic out of INIT: Only keep the essential setup code in the INIT phase. Move business logic or noncritical initializations into the handler to limit the cold start duration.

  • Enable Lambda SnapStart: Available for Java, .NET, and Python runtimes, SnapStart takes a snapshot of your function after the INIT phase and reuses it for cold starts, eliminating the need to repeat the INIT process.

  • Use provisioned concurrency: For functions with consistent traffic, provisioned concurrency keeps execution environments warm, effectively removing cold starts altogether. While this comes with additional costs, it ensures stable performance and will prevent INIT billing spikes.

  • Monitor and iterate: Use CloudWatch metrics like initDuration and tools like CloudSpend to continuously track which functions need tuning. Optimization is an ongoing process, especially as AWS updates its pricing and behavior. 

Final thoughts

AWS’ decision to bill for the INIT phase across all Lambda configurations is a natural evolution of the serverless billing model. While the impact might be small at first glance, it opens the door to cost increases if cold starts go unmanaged.

This update highlights the growing need for precise, real-time cost visibility. With CloudSpend, teams can spot trends early, forecast better, and optimize cloud usage before bills become bloated. If your workloads rely on Lambda, now’s the time to review your functions, tune performance, and put smarter cost controls in place.