What Is Atlassian Forge? FAQ & Answers

With the recent announcement that Atlassian will end support for Connect in 2026, Forge is no longer just the recommended approach; it is the future of cloud app development for Jira and Confluence. Atlassian Forge has quickly become the standard for building cloud apps across the Atlassian ecosystem. It offers a fully managed development environment, deep platform integration, and growing support for enterprise needs. This FAQ answers the most important questions about Forge: what it is, how it works, what it can do, and how to plan for its adoption. From pricing and storage to migration strategies and real-world examples, this guide gives you a clear, structured starting point.

What Is Atlassian Forge?

Forge is Atlassian’s serverless cloud app development platform designed for building secure, scalable, and reliable apps across the entire Atlassian ecosystem, including Jira, Confluence, Compass, and Bitbucket. It enables developers to build fully functional apps quickly, without managing hosting, authentication, or scaling. With Forge, everything runs within Atlassian’s infrastructure using a managed runtime, strict permission controls, and built-in security. You define your app modules using a manifest file and write backend logic in Node.js or TypeScript. Forge handles deployment, execution, and isolation, allowing teams to focus on delivering features rather than infrastructure. Apps can be custom-built for internal use or distributed through the Atlassian Marketplace, which provides a centralized location for publishing, licensing, and managing Forge-based cloud apps, and developers can start building in just a few hours with multiple development environments available out of the box.

Atlassian introduced Forge in 2021 and has continually added features. Unlike legacy cloud app frameworks that require external infrastructure and token flows, Forge provides a fully managed execution environment. For a complete overview, you can visit the Atlassian Forge documentation.

How does the Atlassian Forge platform work?

The Atlassian Forge platform provides an end-to-end environment for cloud app development within the Atlassian ecosystem, covering everything from creation to deployment and monitoring. It is designed to remove infrastructure overhead by offering a serverless architecture, built-in authentication, automatic scaling, and deep product integration out of the box. Whether you’re building an internal integration or a Marketplace app, Forge handles the heavy lifting so you can focus on business logic and user experience.

It includes everything needed to develop, test, deploy, and monitor apps across the Atlassian ecosystem, including Jira, Confluence, Compass, and Bitbucket. It starts with the Forge CLI tools including forge login, forge create, forge tunnel, forge deploy, and forge install. The manifest.yml file defines your app modules, such as UI Kit, Custom UI, REST API endpoints, event listeners, or scheduled jobs.

When you deploy, Atlassian builds a secure container, provisions storage, permissions, and runtime. Your app automatically scales with user demand. You can test updates live using forge tunnel which allows instant logs and viewable updates inside Jira, Confluence, or any other supported Atlassian product. All of this runs inside Atlassian’s infrastructure, so deployment and maintenance overhead are minimal.

What is the difference between Atlassian Forge UI Kit and Custom UI?

The Atlassian Forge UI system supports two different frontend development models:

1. UI Kit: A set of prebuilt React-like components such as <Text>, <Form>, <Button> that are rendered natively. UI Kit apps load quickly and require minimal asset bundling. They are ideal for configuration screens or simple dialogs across any supported Atlassian product that supports UI modules.
2. Custom UI: A full React application bundled using Webpack. You can include CSS, advanced interactive components, and third-party libraries to deliver rich experiences such as dashboards or custom panels. The @forge/bridge library enables communication between your frontend code and secure backend logic.

Both options use the same runtime environment but offer different trade-offs in development complexity and flexibility.

UI Kit provides a streamlined experience by limiting developers to a set of predefined components and hooks. This makes it faster and easier to build simple interfaces, but it also restricts what’s possible; you cannot use custom styling or external libraries.

Custom UI, by contrast, gives developers full creative freedom. You can use any frontend framework, apply your own styles, and include external libraries to create rich, interactive UIs. However, this flexibility comes with added responsibility: you need to manage your own static assets, handle bundling and optimization, and ensure integration with Forge backend services. While it takes more effort to set up, it enables more advanced and customized interfaces tailored to specific needs.

Feature	UI Kit	Custom UI
Development Speed	Faster setup	More complex setup
Styling & Layout	Limited, no custom CSS	Full control, supports custom styles
Component Flexibility	Predefined Atlassian components only	Any UI library or framework
Asset Management	Handled by Atlassian	Managed by developer
Performance	Fast and lightweight	Depends on asset optimization
Ideal Use Cases	Simple interfaces, quick extensions	Rich UIs, dashboards, branded components

You can find summaries and supported components in the UI Kit documentation and the Custom UI overview.

What is Atlassian Forge Storage?

Atlassian Forge Storage is a secure, built-in key-value storage system provided by the Forge platform. It allows your app to store small pieces of structured data—like configuration settings, feature flags, user preferences, or operational state—without needing an external database or infrastructure.

Each Forge app has access to its own isolated storage namespace. You can scope the data at three levels:

• Installation-level (data shared across all users of a single app installation)
• User-level (data specific to an individual user)
• Global-level (data accessible to all installations of the app)

The storage system is managed entirely by Atlassian, meaning it is automatically encrypted, sandboxed per app, and compliant with Atlassian’s platform security standards. This makes Forge Storage a great fit for lightweight and secure data persistence use cases.

For more advanced scenarios requiring complex queries or relational structure, you can combine Forge Storage with Atlassian Forge SQL. For a complete guide, visit the Atlassian Forge storage documentation.

What is Atlassian Forge SQL?

Atlassian Forge SQL is a built-in, fully managed relational database service designed specifically for Forge apps. It lets developers store, organize, and query structured data using standard ANSI SQL without needing to set up or maintain external infrastructure.

Each app installation is provisioned with its own isolated database instance hosted on Atlassian’s infrastructure. This ensures strong data separation, improved security, and compliance with multi-tenant cloud architecture best practices.

Forge SQL is optimized for apps that require structured, relational data such as reporting dashboards, configurable business logic, or internal tools that go beyond simple key-value storage. Because it integrates natively with the Forge runtime, developers can manage schema creation, updates, and migrations using built-in tools and triggers.

Key advantages include:

• Native support for SQL queries and joins
• Per-installation database isolation
• Schema versioning and controlled migration
• Tight integration with other Forge services and APIs

Forge SQL helps simplify data persistence for complex use cases while maintaining high performance and security. It complements simpler options like Forge Storage, giving developers flexibility in how they model app data.

To learn more, explore the Atlassian Forge SQL documentation.

What is the Atlassian Forge API?

The Atlassian Forge API provides a comprehensive set of tools and libraries that allow developers to interact with Atlassian cloud products securely and efficiently. Rather than requiring manual authentication tokens or external infrastructure, the Forge API enables your app to make authenticated calls directly from the Forge runtime environment.

Using the Forge API, developers can:

• Access Jira or Confluence data through built-in methods like requestJira or requestConfluence.
• Perform secure API calls to Atlassian’s REST endpoints from backend functions.
• Handle platform events (like issue creation or page updates) via Forge triggers.
• Enable communication between frontend UI and backend logic using the @forge/bridge module in Custom UI apps.

All of these operations are executed within Forge’s managed infrastructure, adhering to strict permission scopes and platform-level security. This eliminates the complexity of managing tokens or maintaining OAuth flows, and ensures safe, context-aware access to Atlassian product data.

How to get started with Atlassian Forge?

Getting started with Forge is straightforward. Here’s a high-level overview:

1. Install the Forge CLI: Start by installing the Forge command line interface. Follow the CLI installation guide.
2. Set up your development environment: Use the CLI to register, log in, and create your first app using a pre-configured template.
3. Build your app: Choose your frontend approach (UI Kit or Custom UI), define functions, permissions, and modules.
4. Deploy and test: Push your app to different environments (development, staging, production), and test it directly in your Atlassian instance.
5. Distribute or install: Deploy your app internally or publish it to the Atlassian Marketplace.

Follow the Forge getting started tutorial for full step-by-step instructions.

What is Atlassian Forge pricing?

Forge remains free through December 31, 2025. Starting January 1, 2026, Atlassian will introduce a consumption-based pricing model with a generous free tier. Developers will be charged monthly in arrears once they exceed free usage thresholds.

The pricing will apply to specific Forge capabilities that incur operational costs. These include:

• Function execution time (GB-seconds)
• Key-value storage: data read, written, and stored
• Logs: data written

Indicative pricing includes:

• 100,000 GB-seconds of function execution free, then ~$0.000024 per GB-second
• 0.1 GB of data read and written free, then ~$0.10 per GB read and ~$2.10 per GB written
• 5 GB of storage free, then ~$0.42 per GB

Tools to track usage and forecast costs will be made available. Only apps that exceed the free tier will be eligible for enhanced support and financially-backed SLAs.

You can find details in the Forge pricing preview.

How to Build Rovo Agents Using Atlassian Forge?

Rovo Agents are Atlassian’s AI-powered assistants that help users interact with tools and data using natural language. With Forge, developers can extend these agents to make them context-aware, secure, and deeply integrated into their team’s environment.

Forge provides two modules for building and extending Rovo Agents:

• The rovo:agent module defines how an agent responds to prompts, integrating AI into your app’s interface.
• The action module allows the agent to execute specific tasks like calling APIs, querying databases, or triggering workflows.

This setup allows you to:

• Connect agents to private or internal datasets securely
• Delegate complex or strict logic to backend functions
• Clarify data context to improve AI understanding
• Combine AI output with UI elements or workflows

Agents built with Forge can be shared privately or publicly via the Atlassian Marketplace. Atlassian enforces safety screening and acceptable use policies for all agents using Rovo APIs.

Learn more in the Forge Rovo documentation.

Is Forge suitable for enterprise-level apps?

Yes, Atlassian Forge is increasingly suitable for enterprise-grade apps. It supports features like higher memory and CPU allocations, making it viable for complex use cases such as background processing, reporting, and document conversion.

Forge apps benefit from enterprise-level platform security, including SOC2 compliance, strict permission scopes, and sandboxed execution environments. Atlassian manages hosting, scaling, and availability—ensuring high reliability and reducing operational overhead for app developers.

For organizations with compliance needs, Forge also supports data residency, allowing apps to store data in specific geographic regions based on customer or regulatory requirements.

Together, these capabilities make Forge a strong foundation for building scalable, secure, and compliant apps tailored for large teams and enterprise environments.

Can I migrate an existing Connect app to Forge?

Yes, you can migrate an existing Connect app to Forge, but it often requires a partial or phased approach. Forge is a fundamentally different platform: serverless, managed, and manifest-driven, so a direct one-to-one conversion is rarely possible. Developers typically rebuild parts of their app in Forge while retaining legacy components in Connect until a full transition is feasible.

Atlassian also supports hybrid Connect + Forge apps, where certain modules, such as UI Kit pages or backend logic, are implemented in Forge and embedded in a Connect app. This allows teams to gradually adopt Forge without losing functionality or forcing a rewrite. However, limitations exist, including differences in authentication, UI rendering (iframe vs native), and event handling. Planning the migration carefully with Atlassian’s Connect to Forge migration guide is strongly recommended.

How does Atlassian Connect vs Forge compare?

Atlassian Connect and Forge are both frameworks for building cloud apps, but they differ significantly in architecture, security, and developer experience.

Connect apps run on external infrastructure controlled by the app vendor. This gives developers full flexibility but also requires them to manage hosting, security, scaling, and compliance. Connect apps communicate with Atlassian products via REST APIs and iframes, which can introduce complexity and latency.

Forge apps, by contrast, run entirely within Atlassian’s infrastructure. Forge provides a serverless environment with built-in authentication, permission scopes, data storage, and UI components. This simplifies development, improves security, and enables tighter integration with Atlassian products.

Here is how Atlassian Connect vs Forge platforms compare:

Feature	Atlassian Connect	Atlassian Forge
Hosting	External to Atlassian	Fully managed platform
Authentication	OAuth, JWT	Built-in execution context
UI	iframe	UI Kit or Custom UI
Storage	External database	Built-in key-value and SQL
Maintenance	Developer responsibility	Managed by Atlassian

While Connect has been widely used, Atlassian has announced that support will end in 2026, making Forge the strategic direction for all new app development.

What are the limitations of Atlassian Forge?

Forge is a powerful platform, but it has several technical constraints to be aware of:

• Execution limits: Synchronous functions have a ~25-second timeout; asynchronous ones can run up to 15 minutes.
• Cold starts: Initial requests may take longer to execute, especially in low-traffic apps.
• Quota-based scaling: Resource limits (compute time, storage) are based on active user seats.
• Node.js restrictions: Only a subset of Node.js APIs is available—no file system access or native modules.
• Rate limiting: Forge is still subject to Atlassian product API limits.
• Data residency: Non-US hosting regions are limited but improving.
• Storage limits: Forge Storage and Logs have defined quotas per app or seat.
• Long-running jobs: Complex tasks must be split into smaller units using Async Events or scheduled triggers.

Despite these constraints, Forge is evolving rapidly and continues to expand its enterprise and performance capabilities.

What are common mistakes to avoid when building Forge apps?

1. Over-requesting permissions: Declaring unnecessary scopes in manifest.yml can trigger approval delays and security reviews. Always request the minimum required.
2. Misusing storage: Using key-value Forge Storage for relational data instead of Forge SQL can lead to performance and structure issues. Choose storage types appropriately.
3. Ignoring cold starts: For Custom UI apps, large frontend bundles lead to slower load times. Use code splitting and asset optimization.
4. Poor caching: Not caching API responses or UI components can increase app latency and inflate usage costs.
5. Missing context: Forge functions run in specific user or app contexts. Ensure your logic respects scopes and user roles.

Best practices include writing modular logic, testing frequently with forge tunnel, using Custom UI only when needed, and optimizing SQL schema early.

What are some successful apps built with Forge?

Several popular and fast-growing apps on the Atlassian Marketplace are built using Forge:

• Smart Checklist for Jira (Pro) by TitanApps uses Forge modules to add lightweight task lists to issues.
• Issue Templates Pro by Narva Software speeds up issue creation by letting users apply reusable templates for issue summaries and descriptions.
• Epic Sum Up by APTIS simplifies planning, budget tracking, and bulk issue editing. It provides performance improvements and enhanced data visibility with native UI integration.
• Mria CRM is built entirely on Forge to provide Jira-native customer relationship management without any external servers.

You can browse featured Forge-built apps in the Atlassian Marketplace to see how others are using the platform effectively.

What is the Atlassian Forge roadmap?

Atlassian continues to invest heavily in Forge, with a roadmap focused on expanding platform capabilities and improving support for complex use cases. Key areas of ongoing development include performance enhancements, expanded data residency options, Forge SQL improvements, and AI-related features such as Rovo integration.

While exact timelines are not always published, Atlassian regularly updates Forge documentation and developer tools to reflect what’s coming. Developers are encouraged to monitor Forge public roadmap and stay connected through community channels for announcements.

Why Mria CRM uses Atlassian Forge?

At Mria CRM we chose Forge because it allows us to build a fully integrated CRM inside Jira without any external infrastructure. We use Forge SQL for data storage, UI Kit and Custom UI to deliver friendly interfaces, event triggers for automation, and the platform APIs to interact with Jira issues in real time. Since Forge runs entirely in Atlassian’s cloud, our app scales seamlessly and remains secure. Forge has become the foundation of our Jira-native CRM.