RFC-152: Increasing maximum memory for Forge functions

Project Summary

Atlassian is evaluating an increase to the maximum memory that can be allocated to a Forge function at runtime. This will allow memory-intensive workloads to run natively on the Forge functions-as-a-service runtime, and may also improve performance for CPU-bound and memory-bound workloads.

Publish: 23 October 2026
Discuss: 30 October 2026
Resolve: 6 November 2026

Problem

Forge functions currently allow a maximum memory allocation of 1,024 MB at runtime.

We’d like to offer higher limits to app developers where it makes sense; opening up new use cases to be hosted natively on Forge, and providing an additional tuning lever for developers to optimise cost vs. performance.

Proposed solution

We are exploring whether or not the developer community would find it valuable for us to increase this limit.

If roadmapped, apps would be allowed to request up to 5,120 MB per function, which can be specified in the app’s manifest.yml either in the app.runtime.memoryMB property (which will apply to all functions deployed by the app), or in the modules.function.runtime.memoryMB property (which will apply to just that function).

If unspecified, the default value of 512 MB remains unchanged.

CPU would be scaled proportionately to the amount of memory configured. The current maximum of 1,024 MB allocates approximately 0.5 vCPU. At 5,120 MB, the function would receive approximately 3 vCPU.

Usage would continue to be charged at the current published rate of $0.000025 per GB-second. The free usage threshold of 200,000 GB-seconds per month would remain unchanged, but would be consumed faster at higher memory allocations. For example, 200,000 GB-seconds covers about 40,000 seconds of runtime at 5 GB, versus 200,000 seconds at 1 GB.

Asks

We are particularly interested in whether this change would be valuable for you.

What is your use case, and would you adopt this increased limit if it was available? How much memory would you need (is 5GB the right maximum)?

What additional tooling or observability would you need from the Forge platform to be able to tune memory settings effectively?

Are there any concerns or unanswered questions in this proposal?

@HeyJoe, quickly: “RFC-151” is already taken by RFC-151: Migrating to the new dashboard widgets module. Next free number appears to be RFC-152,

Oh good grief! Thanks for catching. Fixed

@HeyJoe, as I read this RFC, I am wondering about the current observability story for Forge apps. Is my understanding correct that the Forge platform (console or elsewhere) currently exposes no data that would allow us to track memory usage for an app’s functions? If so, is anything else in the pipeline for better memory/CPU observability, or do partners have to collect their own metrics (to the extent possible)?

I’m wondering how we would answer whether we need more memory for functions. Maybe if we already configured 1024 MB and see out-of-memory errors? Or is there somewhere else I should look?

There are currently three big hurdles that prevent us from achieving Runs on Atlassian for our Figma / Zeplin apps:

  1. Customer-managed egress is not RoA
  2. Forge does not support caching (we could solve this with Forge Object Store)
  3. Forge functions hit out-of-memory boundaries when dealing with large Figma files

Together, these three issues made us stick with Forge Remote. The GCP Firebase function responsible for exporting Figma files (point 3) is assigned 8GB of memory. This is because it retrieves the export in memory, turns it into a dataURI string and stores it in cache. As functions serve multiple concurrent requests, and Figma files can be very large (in the 100s of MBs), we found that 1GB is not enough.

Unfortunately, Forge does not have caching, but we could replace that with Object Store. So if we can host the Figma file export function on Forge, we could write the output to Object Store and serve it from there.

That would only leave us the CME issue to tackle in order to achieve RoA.

So yes, we would very much welcome configurable memory sizes. I would also love to see configurable CPU. It would be great if Forge Functions would behave similar to Forge Containers with regard to resource allocation

Cheers,

Remie

Thanks for putting this up. We’d use it, and we have numbers, so here’s our case.

Short version: the 1 GB memory limit is the only reason our app caps files at 500 MB. 2–3 GB for one function would fix that, and better memory visibility in forge logs would help just as much.

Our use case

We build Storage Saver, a Forge app (Runs on Atlassian) that moves large Jira attachments into Object Store and restores them on request. All of that runs in one async consumer at memoryMB: 1024 with the 900 s timeout. The pipeline is:

Jira download → SHA-256 → presigned PUT to Object Store

We pass the Jira response stream straight in as the PUT body (duplex: 'half'), nothing buffered on our side. RSS still goes up by about the size of the file during the PUT. Restore (multipart POST back to Jira) behaves the same way: a 450 MB restore ended at 634 MB.

What we measured

From our dev deployment. RSS is process.memoryUsage().rss at the end of each stage, so the real peaks are somewhat higher.

File RSS at start RSS at end Result
250 MB 90 MB 383 MB ok, 48 s
500 MB 383 MB (warm) 637 MB ok, 92 s
537 MB 91 MB 675 MB ok, 99 s
537 MB 1,061 MB (warm) – 900 s timeout
1.07 GB – ~1,060 MB failed 4/4

So roughly 130 MB + 1x the file. The 1.07 GB file died twice on the timeout with nothing at all in the logs, and twice with an HTTP 500 from Object Store at ~1.06 GB RSS. Object Store itself handles that size fine; in an earlier test the same file round-tripped with a matching SHA-256.

Why 500 MB: warm containers

What actually forced our hand is container reuse. Sometimes an invocation starts in a container that still has the previous job’s memory (“warm” in the table), and we’ve seen starting RSS anywhere between 82 MB and ~1 GB. The same 537 MB file that took 99 s on a fresh container timed out on a warm one. So we cap files at 500 MB to leave headroom, which means turning away exactly the attachments people most want off their Jira storage.

On your questions

  1. Adoption: yes, on day one, but only for that one function. Everything else is fine at 512 MB.
  2. How much: 2 GB gets us close to the ~1 GB object size, 3 GB would make it safe with warm containers. 5 GB is more than we’d need.
  3. Observability: honestly, this matters as much to us as the memory itself.
    • Peak RSS per invocation in forge logs / the Developer Console. We can only sample memoryUsage() ourselves and miss the peak.
    • A clear OOM event that isn’t just a timeout. Two of our failures were silent 900 s timeouts and we still don’t know whether they were OOM kills.
    • The starting memory of an invocation, or a way to ask for a fresh container for heavy consumers.
    • Is memoryMB actually enforced as a hard cap? In an early test a 1 GB transfer peaked at 1,328 MB in a 1,024 MB function and survived; later the same file died around 1.06 GB.
  4. Open questions:
    • Do the 900 s timeout and the 180 s limit per outbound request stay the same? A 1 GB PUT has to fit inside both.
    • Is a streamed request body expected to cost a full copy of the file in the Forge runtime? If uploads streamed with flat memory, we’d need a lot less of this.
    • Could you document the maximum Object Store object size? With more memory, that becomes our per-file limit.

Happy to re-run any of this on an EAP.

Hey Tobi,

That’s right - there’s no out-of-the-box support for observability of memory consumption in Forge functions.

You could base your tuning on local tests, or implement custom metrics that report on memory consumption.

If we implemented better out-of-the-box observability for memory usage, what metrics would you like to see? Better categorisation of out of memory errors? Metrics on peak and/or mean memory usage per invocation?

Thanks for this feedback, Remie!

I don’t have any updates to share on points 1 and 2, but there are discussions happening about both of them currently.

Thanks for this feedback @MichalKrysiuk !

Regarding your observability points:

  • As part of evaluating this project, we can explore adding information on peak rss per invocation to the developer console and/or logs, and improving graceful termination behaviour from out of memory errors.

  • I’m surprised that you are seeing noticeable differences in behaviour for warm vs. cold starts. Are you sure that you are not accidentally keeping dangling references or promises to the previous file uploads in your global state?

  • The memoryMb value is a hard cap enforced by the platform the functions execute on.

Regarding your questions:

Do the 900 s timeout and the 180 s limit per outbound request stay the same? A 1 GB PUT has to fit inside both.

The 900s limit is a hard ceiling we can’t increase. For longer processing times, you may want to consider using Forge Container services. I’m not certain how flexible the 180s limit for outbound requests is, and I will follow up with the engineering team on this. I suspect there may be downstream hard limits that will hit timeouts.

Is a streamed request body expected to cost a full copy of the file in the Forge runtime? If uploads streamed with flat memory, we’d need a lot less of this.

I’ll check with the storage team about the expected behaviour here!

Could you document the maximum Object Store object size? With more memory, that becomes our per-file limit.

According to https://developer.atlassian.com/platform/forge/limits-object-store/, it’s 1GB.

Yes, this, but I would prefer p50/95/99 over mean and peak, and per-function is probably enough to decide whether I should scale memory up or down. I assume each function across all invocations will have roughly similar characteristics. If it doesn’t, the spread of p50/95/99 would hint at it.

This article has some ideas as well, highlighting that more memory (and as a result CPU) may not actually cost you more money: Operating Lambda: Performance optimization – Part 2 | AWS Compute Blog

Hello,

This increase of maximum memory limit would be definitely useful for our apps.

In one of our apps we already set 1024 MB for the whole app. Field recalculation runs on a scheduled trigger every 5 minutes (300s timeout). Each run does a JQL search for issues updated since the last run, loads them into memory with all fields and changelogs (plus bulk changelogs for the status-history fields), recalculates the custom fields, and writes the values back. Some of those fields are user scripts that run in QuickJS compiled to WASM, so it’s a mix of memory-heavy and CPU-heavy work. On busy sites the number of updated issues per window varies a lot, and we already have logic that hands the leftover work to a backfill job when a run can’t finish. Backfill works in slices of 1000 issues. For us, more CPU per invocation probably matters as much as more memory, because it means more issues per tick and fewer runs that spill into backfill.

In the second app most functions are fine at 512 MB. The exception is the JCMA processor for DC->Cloud migrations that applies namespace mappings and migrates workflow rules for a whole site in one invocation. We recently raised it to 1024 MB, and it runs close to the 15 min limit. Memory there grows with the size of the customer’s instance, so right now we have no room left at the top end.

Would we adopt it? Probably yes, but only for specific functions, not for the whole app. I guess 2-3 GB would be enough for both cases, so 5 GB as the max sounds reasonable.

In case of observability it would be nice to see p50/p95/p99 memory per function, as already discussed.

Hi everyone,

Thank you for the feedback and the concrete examples you shared. We’re now closing RFC-152 to further feedback. Based on the positive response, we intend to progress the proposal into implementation.

What did we hear?

• There is demand for higher memory limits across file processing, field recalculation and migration workloads.

• Better memory observability is important for making this useful. You asked for peak memory usage, per-function p50/p95/p99 reporting, and clearer identification of out-of-memory failures.

• There is interest in configuring CPU independently of memory. The underlying platform we use does not give us the ablity to offer that, but it’s good feedback for long term consideration. For now, CPU will continue to scale with memory allocation. As highlighted in the discussion, higher memory can sometimes reduce execution time enough to offset the additional cost.

• Caching and customer-managed egress remain separate concerns. This change alone won’t resolve all the blockers raised around Runs on Atlassian.

What did we change?

  • We’re expanding our planning to include memory observability, rather than only raising the configurable limit. We’re exploring which metrics we can expose through the Developer Console and/or logs, including the percentile reporting and clearer failure diagnostics requested here.

  • Our preference is to deliver these improvements alongside the higher limit, but we may separate delivery if observability would substantially delay the memory increase. The exact metrics and presentation are still being worked through.

  • The 900-second maximum function runtime, 180-second outbound-request timeout for async events, and documented 1 GB Object Store object limit are unchanged by this proposal.

  • Several of you expect 2–3 GB to be sufficient, particularly when configured for individual functions. Some workloads need an even higher limit. We will explore the feasibility of offering a maximum limit than 5MB.

What is coming next?

Please keep an eye on the Forge developer changelog for further updates. We’ll reach out to those who’ve expressed interest in testing once we have something ready to validate.

The increase will remain opt-in, with per-function configuration supported and the default allocation unchanged at 512 MB. There are no changes proposed to the compute pricing rate or free usage allowance.