Please help me work out the math here, as I think I am doing this wrong.

A Lambda of 128mb costs $0.0000000021/ms, this works out $0.00756/hour.

A Lambda of 512mb costs $0.0000000083/ms, this works out $0.02988/hour.

Now if you look at EC2:

t4g.nano $0.0042/hour (0.5 GiB ram)

t4g.micro	$0.0084/hour (1GiB ram).

But... the Lambda will likely not run 100% of the time, and will stay warm for 10 minutes (not sure here?). And the RAM usage would be much better utilized if you got a function running, rather than an entire VPC.

Given all that, if the function can run with 128mb or less, it seems like a no-brainer to use Lambda.

However, if the function is bigger, it would only make sense to put it in an EC2 if it runs more than 30% of the time ($0.0084/hour cost of t4g.micro divided by 0.02988/h cost of 512mb lambda).

So why is everyone against Lambdas citing costs as the primary reason...?

Hello, pretty new to building on AWS so I pretty much just threw everything in lambda for the heavy compute and have light polling on EC2. I am doing all CPU and somewhat memory intensive work that lasts around 1-7 minutes on async lambda functions, which sends a webhook back to the polling bot (free t2 micro) when it is complete. For my entire project, lambda is accruing over 50% of the total costs which seems somewhat high as I have around 10 daily users on my service.

Perhaps it is better to wait it out and see how my SaaS stabilises as we are in a volite period as we enter the market, so it's kinda hard to forecast with any precision on our expected usage over the coming months.

Am I better off having an EC2 instance do all of the computation asynchronously or is it better to just keep it in lambda? Better can mean many things, but I mean long term economic scalability. I tried to read some economics on lambda/EC2 but it wasn't that clear and I still lack the intuition of when / when not to use lambda.

It will take some time to move everything onto an ec2 instance first of all, and then configure everything to run asynchronously and scale nicely, so I imagine the learning curve is harder, but it would be cheaper as a result? .

AWS Lambda pricing is promising - you don't pay for idle, and you are billed for 100 milliseconds intervals. The pricing model is described thoroughly in this page, but honestly - do you really know what the cost of each function is?

There are too many parameters that you need to take into account when calculating the cost of each function, which turns out to be tough work. Also, what about monthly cost estimation?

• Blog post: https://blog.epsagon.com/how-much-does-my-lambda-function-cost

• Open source tool: https://github.com/epsagon/lambda-cost-calculator

Hello everyone! For a client I need to create an API endpoint that he will call as a SaaS.

The API is quite simple, it's just a sentiment endpoint on text messages to categorised which people are interested in a product and then callback. I think I'm going to use Amazon comprehend for that purpose, or apply some GPTs just to extract more informations like "negative but open to dialogue"...

We will receive around 23k call per month (~750-800 per day). I'm wondering if AWS lambda Is the right choice in terms of pricing, scalability in order to maximize the output and minimize our cost. Using an API gateway to dispatch the calls could be enough or it's better to use some sqs to increase scalability and performance? Will AWS lambda automatically handle for example 50-100 currency calls?

What's your opinion about it? Is it the right choice?

Thank you guys!

As title asks. Lambda functions are so cheap, I am curious if anyone actually runs them at a scale where costs are now a concern? If so, that would be impressive.

Hey everyone, So, I wanted to share some hard-won lessons about optimizing Lambda function costs when you're dealing with a lot of invocations. We're talking millions per day. Initially, we just deployed our functions and didn't really think about the cost implications too much. Bad idea, obviously. The bill started creeping up, and suddenly, Lambda was a significant chunk of our AWS spend. First thing we tackled was memory allocation. It's tempting to just crank it up, but that's a surefire way to burn money. We used CloudWatch metrics (Duration, Invocations, Errors) to really dial in the minimum memory each function needed. This made a surprisingly big difference. y'know, we also found some functions were consistently timing out, and bumping up memory there actually reduced cost by letting them complete successfully. Next, we looked at function duration. Some functions were doing a lot of unnecessary work. We optimized code, reduced dependencies, and made sure we were only pulling in what we absolutely needed. For Python Lambdas, using layers helped a bunch to keep our deployment packages small, tbh. Also, cold starts were a pain, so we started experimenting with provisioned concurrency for our most critical functions. This added some cost, but the improved performance and reduced latency were worth it in our case. Another big win was analyzing our invocation patterns. We found that some functions were being invoked far more often than necessary due to inefficient event triggers. We tweaked our event sources (Kinesis, SQS, etc.) to batch records more effectively and reduce the overall number of invocations. Finally, we implemented better monitoring and alerting. CloudWatch alarms are your friend. We set up alerts for function duration, error rates, and overall cost. This helped us quickly identify and address any new performance or cost issues. Anyone else have similar experiences or tips to share? I'm always looking for new ideas!

Did you ever look at your Lambda bill thinking:

𝗪𝗵𝗮𝘁 𝘁𝗵𝗲 𝗵𝗲𝗹𝗹 𝗮𝗿𝗲 𝗚𝗕-𝘀𝗲𝗰𝗼𝗻𝗱𝘀? 🤨

It doesn't sound initiative, but it's also not complex.

A breakdown including examples ↓

𝗣𝗿𝗲𝗳𝗮𝗰𝗲

One of Lambda's major differences to services like EC2 or Fargate is the pay-per-use pricing: 𝘆𝗼𝘂'𝗿𝗲 𝗼𝗻𝗹𝘆 𝗽𝗮𝘆𝗶𝗻𝗴 𝘄𝗵𝗲𝗻 𝘆𝗼𝘂𝗿 𝗰𝗼𝗱𝗲 𝗶𝘀 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗲𝘅𝗲𝗰𝘂𝘁𝗲𝗱.

In detail, you're paying for GB-seconds.

Let's have a look into that:

There are several measures to take for #Lambda

• number of executions

• execution durations

• assigned memory to your Lambda functions

Calculation of the duration starts when the code inside your handler function is executed & stops when it returns or is terminated.

What's worth noting: global code (outside your handler) is executed at cold starts & 𝗶𝘀𝗻'𝘁 𝗯𝗶𝗹𝗹𝗲𝗱 𝗳𝗼𝗿 𝘁𝗵𝗲 𝗳𝗶𝗿𝘀𝘁 𝟭𝟬 𝘀𝗲𝗰𝗼𝗻𝗱𝘀.

But back to the cost calculation with a look at AWS free tier.

For Lambda, it is 𝟰𝟬𝟬,𝟬𝟬𝟬 𝗚𝗕-𝘀𝗲𝗰𝗼𝗻𝗱𝘀 per month.

Breakdown: we're paying for 𝗴𝗶𝗴𝗮𝗯𝘆𝘁𝗲𝘀 𝗼𝗳 𝗺𝗲𝗺𝗼𝗿𝘆 assigned to your function 𝗽𝗲𝗿 𝗿𝘂𝗻𝗻𝗶𝗻𝗴 𝘀𝗲𝗰𝗼𝗻𝗱.

For our free tier, this means: we got 400,000 seconds worth of a 1GB memory function.

This means more than 110 hours or 4 days!

If you change the memory assignment of your function, we'll get other numbers for the free tier:

• 128MB => ~880 hours / 36 days

• 256 MB => ~440 hours / 18 days

• 512MB => ~ 220 hours / 9 days

• 3072MB => ~37 hours / 1.5 days

As seen, calculations are not complex at all.

Let's have a look at a detailed example:

Running a function for 𝗼𝗻𝗲 𝘀𝗲𝗰𝗼𝗻𝗱 (𝟭𝟬𝟬𝟬𝗺𝘀) with 𝟭𝟮𝟴𝗠𝗕 for 𝗼𝗻𝗲 𝗺𝗶𝗹𝗹𝗶𝗼𝗻 𝘁𝗶𝗺𝗲𝘀.

We're paying for:

• 1ms: $𝟬.𝟬𝟬𝟬𝟬𝟬𝟬𝟬𝟬𝟮𝟭

• 1s: $𝟬.𝟬𝟬𝟬𝟬𝟬𝟮𝟭

=> 1m executions: $𝟮.𝟭𝟬

Is this included?

Yes, the free tier covers this completely.

We receive 400,000 GB-seconds.

That means:

=> 400,000 GB-seconds = 𝟯,𝟮𝟬𝟬,𝟬𝟬𝟬 128MB-seconds

In our example, we're only using 𝟭,𝟬𝟬𝟬,𝟬𝟬𝟬 128MB-seconds! 🤩

Let's switch from a 128MB to a 10GB function.

Now we end up with $𝟬.𝟬𝟬𝟬𝟬𝟬𝟬𝟭𝟲𝟲𝟳 per 10GB-ms.

Which means:

• 1s: $𝟬.𝟬𝟬𝟬𝟭𝟲𝟲𝟳

=> 1m executions: $𝟭𝟲𝟲,𝟳 🤯 🔥

Which are equal to 10,000,000 GB-secs!

So free tier doesn't do a lot here with its 400,000 GB-secs.

This calculation is an example.

Your function will execute computations way faster with those memory (& therefore vCPU) differences.

Also, there's a 𝗦𝘄𝗲𝗲𝘁 𝗦𝗽𝗼𝘁 that we'll show you in this article: https://dashbird.io/blog/aws-lambda-cost-optimization-strategies/

𝘅𝟴𝟲 𝘃𝘀. 𝗔𝗥𝗠

You can choose to run your Lambda's on different architectures.

Our examples were done for x86, but it's more expensive than on ARM/Graviton2!

• x86 Price: $0.0000166667 for every GB-second

• ARM Price: $0.0000133334 for every GB-second

See this article if you'd like to dive even deeper: https://dashbird.io/blog/aws-lambda-pricing-model-explained/

Hi everyone I have a question regarding cost between lambda and ec2 I am building a simple node application using puppeteer that will only act as an api. Obviously don’t expect heavy usage for now but overall Iv read that lambda will be cheaper to run up until heavy usage? Just wanted to get your thoughts if ec2 is better than lambda both in performance and cost. Again this will not be heavily used in either case. Also which ones performance will be better?

I was trying to setup provisioned concurrency in AWS lambda, and wanted some guidance on the cost overhead that I'll bear.

Let's say I decide to setup provisioned concurrency as 5.

My memory size 3072 MB.

Estimated total cost per month: $0.00000005 (cost per ms for 3072 mb) * 1000*60*60*24*30 (total ms in a month) * 5 (provisioned concurrency) = 648 $

A) is this calculation correct?

B) With every update do I have to deploy a new version and setup concurrency?

I'm a bit confused about the Free Tier offering. I've read that AWS Lambda offers a Free Tier with 1 million requests per month and 400,000 GB-seconds of compute time per month, but I'm not sure if this only applies during the initial 12-month Free Tier term or if it's available indefinitely.

Can someone clarify if the AWS Lambda Free Tier is available beyond the first 12 months? And if so, are the 1 million requests and compute time limits still applicable?

I'm working on an application which needs websockets.

Investigating this, it looks like it's possible to set up serverless websockets using API Gateway and Lambda - but I am wondering how expensive this gets.

Lambda is affordable when you are handling REST calls, but in that case you are only using milliseconds of CPU at a time. How does the pricing scale when using lambda for something more long running like a websocket server?

I.e. when my lambda is just waiting for the next WS callback, am I paying for it to be running?

An article I wrote explaining how we reduced our Lambda cost from 2200$ per day to 200$ per day: https://medium.com/foxintelligence-inside/how-we-reduced-lambda-functions-costs-by-thousands-of-dollars-8279b0a69931

On August 1st, AWS started charging for something that was previously free: the initialization phase of Lambdas.
Official blog post here: https://aws.amazon.com/blogs/compute/aws-lambda-standardizes-billing-for-init-phase/

Here’s the weird part: a few days before that change (around July 29th), we saw init times suddenly increase across multiple AWS accounts for one of our clients.

• They went from ~500ms to 1–3+ seconds

• No deployments, no code changes, no new versions

• Just noticeably slower inits out of nowhere

Now, when comparing billing, Lambda costs have more than doubled from July to August with no obvious reason.

Has anyone else noticed the same behavior? Is this just bad timing, or something more deliberate?

If you’re running workloads on Lambdas, I’d recommend checking your metrics and costs. Would love to hear what others are seeing.

What are different approach you will take to avoid those costs impact.

https://aws.amazon.com/blogs/compute/aws-lambda-standardizes-billing-for-init-phase/

Looking for the cheapest way to deploy a yet to be developed application.

It seems to me that Lambda functions behind the API Gateway is the cheapest and most scalable way to deploy a cloud native micro service. Am I wrong to assume this?

The other options from AWS like EC2 (replicate the original server environment), Beanstalk (traditional Java/Python web apps with slightly modified repackaging), ECS/EKS (Docker container image based) are more for backward compatibility with legacy/non cloud native apps and services that cannot/should not be changed.