Jira
monday.com
Why Atlassian Needed a Modern App Development Platform
Building apps for Jira, Confluence, and other Atlassian products has traditionally been a resource-heavy process. Developers had to configure their own servers, ensure uptime, and pass rigorous security checks to get their apps approved for the Atlassian Marketplace. This setup required both development expertise and operational support, slowing app development and increasing costs.
Atlassian Forge was introduced to eliminate these barriers. It is a modern cloud-based app development platform that allows developers to build secure, serverless apps directly within Atlassian’s infrastructure. Forge simplifies building apps, giving developers more time to focus on functionality, while Atlassian handles hosting, security, and scaling.
This article explains Forge’s core features, key benefits, pricing model, and common use cases. Whether you are a developer considering your first Atlassian app or a team looking to transition from Connect to Forge, this guide will help you decide if Forge is the right solution for your business.
What is Atlassian Forge?
Atlassian Forge is a cloud app development platform specifically designed to build apps that extend Jira, Confluence, Bitbucket, and other Atlassian products.
Unlike traditional app development, Forge allows developers to create apps that run securely within Atlassian’s cloud infrastructure. This eliminates the need for external servers and simplifies the development process.
Forge is part of Atlassian’s broader strategy to modernize its cloud ecosystem. It provides developers a streamlined way to build, deploy, and maintain apps that integrate seamlessly with Atlassian products while meeting high security and data residency standards.
Below is a diagram demonstrating the Forge platform architecture.
Note
Recently, UI Kit 1 was deprecated, and UI Kit 2 was renamed as only UI Kit. Please see Forge documentation for details.
Core Features of Atlassian Forge
- Forge CLI
- A command-line interface that simplifies app development and deployment.
- Helps developers manage app environments, view logs, and preview apps locally in real-time.
- UI Kit & Custom UI
- UI Kit: A set of pre-built components that allow developers to build user interfaces quickly while ensuring design consistency with Atlassian products.
- Custom UI: Provides more flexibility for developers to build fully customized frontends using React, JavaScript, HTML, and CSS.
- Serverless Functions (FaaS)
- Apps run on Forge’s serverless architecture, meaning backend functions execute on demand without requiring developers to manage servers.
- Compute power automatically scales based on app usage.
- Secure Data Storage Options
- Forge Key-Value Storage: Simple and fast, ideal for basic data storage.
- Forge Entity Storage: Indexed storage for better query performance.
- Forge RDBMS (Early Access): Full relational database support for more complex data operations.
- Forge Cache (Early Access): High-speed temporary data storage.
- Forge Object Storage (Early Access): Intended for storing larger files and data objects in the future.
- Native Integration with Atlassian Products
- Apps built with Forge integrate deeply with Jira Software, Confluence, Jira Service Management, and Bitbucket.
- Developers can use Forge modules to extend product UIs, automate workflows, and interact with Atlassian APIs.
Forge eliminates the operational burden of hosting and security compliance, allowing developers to focus on building functionality. It also aligns with Atlassian’s long-term cloud strategy, meaning Forge apps are future-proof as the Atlassian ecosystem continues evolving.
Key Benefits of Using Atlassian Forge
Atlassian Forge is more than just a cloud app development platform—it’s a fundamental shift in how apps are built, deployed, and maintained within the Atlassian ecosystem. Developers, Jira administrators, and businesses benefit from increased security, reduced operational overhead, and deeper product integrations.
1. Security & Compliance
Forge apps operate entirely on Atlassian infrastructure, significantly reducing security risks. Developers no longer need to manage their own servers, and customer data never leaves the Atlassian Cloud unless explicitly allowed (egress).
Key security advantages:
- Zero Egress by Default: Data remains within Atlassian systems unless the app explicitly requests external access.
- Granular Permissions: Apps can only access the specific data they need, reducing the risk of over-permissioned apps.
- Data Residency: Forge apps align with Atlassian’s data residency commitments, supporting businesses operating under GDPR, HIPAA, and other regulations.
- OAuth 2.0 for External Integrations: Apps connecting to third-party services benefit from modern, secure authentication.
Note
While Forge enhances security, developers face limitations when troubleshooting issues. App developers can only access logs if users grant permission. If customers restrict log sharing, diagnosing issues can become challenging, requiring users to manually provide logs.
2. Serverless Architecture
Forge is built on a serverless model, meaning developers don’t need to provision, manage, or scale servers. Forge functions are executed on demand, with automatic scaling based on usage.
Key highlights:
- Reduced Costs: No need for dedicated cloud hosting or DevOps support.
- Lower Maintenance: Forge handles backend infrastructure and updates.
- Multiple Data Storage Options:
- Key-Value Storage: Simple, fast storage for lightweight data.
- Secure Storage: Key-value storage for credentials
- Entity Storage: Indexed, better for structured data.
- RDBMS (Early Access): Full relational database (ideal for complex apps).
- Forge Cache (Early Access): Fast, temporary storage.
- Object Storage (Early Access): Large data object storage.
Note
Performance can vary depending on the storage type chosen. Basic key-value storage is fast but lacks indexing and transactions. Entity storage is more robust but has limitations. Complex apps requiring large data operations may still experience slower performance than traditional database setups.
3. Deep Integration with Atlassian Products
Forge apps natively integrate with Jira Software, Confluence, Jira Service Management, and Bitbucket. Forge’s modular architecture and REST APIs make this deep integration possible.
Key integration points:
- Forge Modules: Control how apps appear and interact with Atlassian products (e.g., issue panels, custom fields, admin pages).
- Jira REST API: Automate issue creation, transitions, and custom workflows.
- Confluence REST API: Manage pages, spaces, and content updates.
- Bitbucket API: Automate repository tasks and code workflows.
- Jira Service Management API: Create service requests, automate approvals, and enhance ITSM processes.
Note
Forge has unlocked new UI customization capabilities that were not possible with Connect. For example, for Smart Checklist, we could develop a custom field feature on Forge that allows checklists to be embedded directly into issue creation screens—something that was not achievable with Connect.
Atlassian Forge vs. Atlassian Connect
Choosing the right app development platform is critical when building on Atlassian products like Jira and Confluence. Atlassian Forge and Atlassian Connect are the two primary platforms, each with distinct differences in hosting, security, and performance.
1. Hosting & Data Residency
- Forge: Apps run entirely on Atlassian Cloud infrastructure, eliminating the need for external servers. This is crucial for teams prioritizing security, compliance, and reduced maintenance. Forge apps can qualify for “Runs on Atlassian” badges, signaling zero data egress by default (though developers can still configure external data transfers if needed).
- Connect: Requires developers to host apps on their own infrastructure, increasing hosting costs and adding security responsibilities. Data can flow between customer instances and external servers, creating potential compliance concerns, especially for GDPR or HIPAA-regulated businesses.
Note
Although Forge shifts responsibility for data security to Atlassian, developers are still accountable for data integrity. If an app loses or mishandles data, the vendor remains liable, even though the infrastructure is Atlassian-managed. Recovery is sometimes possible through Atlassian support, but there are risks if backups are not properly handled.
2. Performance & Scalability
- Forge: Built on a serverless architecture, Forge apps scale automatically based on demand, ideal for apps with fluctuating usage patterns. However, serverless compute limits exist (up to 15 minutes for long-running processes), which can require batching or architectural adjustments for complex workloads.
- Connect: Performance depends on the vendor’s infrastructure. While this offers full control over speed and scalability, it also requires ongoing maintenance and investment in cloud resources.
Note
Forge performance is evolving but can still lag compared to self-hosted Connect apps, especially for large-scale data operations. Developers often need to optimize their app logic based on Forge’s available storage types (Key-Value, Entity, RDBMS).
3. Security & Authentication
- Forge: Security is managed within the Atlassian Cloud. Apps may use OAuth 2.0 only when integrating with external services; for internal platform access, authentication is built-in and seamless. Forge apps are subject to Atlassian’s Security Bug Bounty program, providing an extra layer of scrutiny.
- Connect: Security relies on the vendor’s implementation, including JWT authentication and custom authorization systems. This introduces variability in app security depending on the vendor’s practices.
Note
Forge’s centralized security model is more robust but limits developer control when diagnosing issues. Access to app logs is restricted unless users explicitly grant permission, which can delay troubleshooting.
Forge vs Connect Comparison Summary
| Feature | Atlassian Forge | Atlassian Connect |
| Hosting | Atlassian Cloud (serverless) | Vendor-hosted (self-managed) |
| Data Residency | Built-in support | Vendor-managed |
| Performance | Auto-scaling (with limits) | Full control vendor |
| Security | Managed by Atlassian | Vendor responsibility |
| Authentication | Built-in (OAuth 2.0 for external) | JWT, OAuth |
| InfrastructureMaintenance | Minimal | Full vendor responsibility |
| Cost Control | Usage-based pricing (coming soon) | Vendor-defined infrastructure costs |
Note
As Atlassian gradually phases out Connect, developers will need to migrate apps or transition to Connect on Forge. This hybrid approach allows parts of Connect apps to leverage Forge infrastructure while retaining some self-hosted elements.
Read here for more details: Connect on Forge Overview
Atlassian Forge Pricing
Understanding Atlassian Forge’s cost structure is crucial for developers planning to build or migrate apps. While Forge apps are currently free to develop and host, Atlassian has announced plans to introduce a usage-based pricing model in the future.
How Atlassian Plans to Charge for Forge
Atlassian’s upcoming Forge pricing model will be based on:
- Compute time – The duration serverless functions (FaaS) run to handle app logic.
- Storage usage – The volume of data stored using Forge’s key-value storage, entity storage, or upcoming RDBMS solutions.
- Forge App Tiers:
- Free Tier – Intended for small-scale apps and low-usage internal tools.
- Paid Tiers – Pricing will scale based on resource consumption, similar to cloud infrastructure models like AWS Lambda.
Note
Developers can already monitor app resource consumption in the Forge Developer Console. This allows early estimation of potential costs once pricing is introduced, though exact rates are still pending.
Timeline:
Pricing details are expected to roll out gradually, with a full transition planned around 2026.
How Pricing Compares to Connect Apps
Forge:
- Hosting is included as part of the platform, eliminating costs for cloud infrastructure (e.g., AWS, Heroku).
- Developers only pay for the app’s actual usage (compute + storage), making costs predictable and often lower for apps with variable or low traffic.
Connect:
- Vendors bear full responsibility for cloud hosting, database management, and operational costs.
- Costs scale independently of app usage—high fixed costs can impact profitability for smaller apps.
Note
Connect apps often require separate hosting services (e.g., AWS, Heroku) and additional backend infrastructure like Redis and databases, resulting in recurring expenses.
Forge eliminates this need, streamlining both cost structure and operations.
Forge vs Connect Price Comparison
| Cost Factor | Forge (Upcoming Pricing) | Connect |
| Hosting | Included (Atlassian Cloud) | Vendor-managed (AWS, Heroku, etc.) |
| Pricing Model | Usage-based (compute + storage) | Vendor-defined infrastructure costs |
| Upfront Costs | Minimal | Potential server setup costs |
| Cost Variability | Scales with usage | Fixed operational costs |
| Free Tier for Small Apps | Planned | Partially applicable (by utilizing free tiers of third parties (firebase, netlify, etc) |
Key Takeaways:
- Lower entry barriers: Forge’s pricing model makes it easier for small developers to get started while ensuring cost predictability for larger apps.
- Potential cost savings: Vendors migrating from Connect to Forge can eliminate infrastructure costs, which may result in long-term savings, though the migration process can be complex.
- Uncertain final costs: The exact pricing for Forge infrastructure has not yet been finalized. For complex apps, costs could end up being higher than with Connect, meaning vendors should monitor pricing updates and adjust their development plans accordingly.
How to Build an Atlassian Forge App (Overview)
Developing an app with Atlassian Forge is streamlined compared to traditional app development on Jira and Confluence. Forge provides an integrated development environment with tools to simplify setup, development, and deployment.
This section provides a high-level overview of the steps required to create a Forge app. For detailed instructions on setting up your Forge development environment, refer to the Atlassian getting started guide
1. Set Up Your Development Environment
Step 1: Install Forge CLI
- Download and install the Forge Command Line Interface (CLI).
- The CLI is the primary tool to create, deploy, and manage Forge apps.
- It also provides access to logs, environment settings, and a real-time local preview during development.
Command to Install:
npm install -g @forge/cli
Official Guide: Forge CLI Installation
2. Create a Forge App
Step 2: Build the App
- Use Forge CLI to scaffold a new app:
forge create
- Choose a template (e.g., UI Kit, Custom UI, or a function-only app).
- Select your target product: Jira, Confluence, or Bitbucket.
Forge UI Options:
- UI Kit: Pre-built Atlassian-styled components for fast, native-like development.
- Custom UI: Full control over the front-end using React, JavaScript, CSS, and custom assets.
- Function-only (No UI): Backend logic without user interface—useful for automation or background tasks. You can also realize “AI agent” with the Rovo Agent option.
Note
Developers can technically skip UI altogether if building a purely backend automation tool.
Developers can build the app from scratch with “forge register YourAppName”
Forge allows creating field customizations and complex interfaces directly within issue creation screens, which is impossible in Connect.
Step 3: Configure Permissions
To define and manage permissions in your Forge app, specify the required OAuth 2.0 scopes in the manifest.yml file. This configuration controls your app’s access to various Atlassian product APIs.
- Apps can request specific product scopes like:
- read:jira-work (to read issues)
- write:jira-work (to modify issues)
- read:confluence-content (to retrieve Confluence pages)
Example of defining scopes:
permissions:
scopes:
– ‘read:confluence-content.summary’
– ‘write:jira-work’
For detailed guidance on setting up permissions, please refer to the Forge Permissions Documentation.
Note
OAuth 2.0 is only needed if the app interacts with external APIs.
Forge apps do not require OAuth to access Atlassian platform data like Jira issues—it works out of the box.
Step 4: Deploy to Atlassian Cloud
After configuring your app and setting the necessary permissions, deploy your app using the Forge Command Line Interface (CLI).
- Navigate to your app’s root directory in the terminal. Deploy the app by running:
forge deploy
This command bundles and deploys your app’s code to the Forge platform.
- Install the app on your Atlassian site into your Jira, Confluence, or Bitbucket instance:
forge install
- Follow the prompts to select the environment and specify the site where you want to install the app.
For comprehensive instructions on deploying and installing Forge apps, consult the Forge Deployment Guide.
5. Publish to Atlassian Marketplace (Optional)
Step 5: Publish to the Marketplace
- If you plan to distribute your app commercially, submit it to the Atlassian Marketplace.
- Publishing is simpler than Connect, so less infrastructure validation is required.
Check for more details:
Publishing Forge Apps on Marketplace
Note
Updating apps is faster on Forge compared to Connect, reducing downtime and improving the release cycle.
Forge streamlines the approval process for Marketplace listings, especially for security reviews.
Key Steps to Build a Forge App
| Step | Description | Reference Link |
| Step 1: Install Forge CLI & Set Up Environment | Download and install the Forge CLI. Authenticate with your Atlassian account and set up your development environment. | Forge CLI Installation & Setup |
| Step 2: Create an app | Choose UI Kit or Custom UI—decide between UI Kit for pre-built Atlassian components or Custom UI for fully custom front-end development. | UI Kit vs. Custom UI |
| Develop app features—implement app logic using serverless functions (FaaS), Forge Modules, REST APIs, and Atlassian product integrations. | Forge Modules Overview |
| Step 3: Define App Permissions | Specify necessary OAuth 2.0 scopes and product access in manifest.yml to control app capabilities. | Forge Permissions Documentation |
| Step 4: Deploy App to Atlassian Cloud | Deploy your app to Forge using forge deploy. Install it on your Jira, Confluence, or Bitbucket instance. | Forge Deployment Guide |
| Step 5: Publish on Atlassian Marketplace | Prepare your app for Marketplace submission. Submit security, privacy, and data residency details. | Publishing Forge Apps on Marketplace |
Common Challenges & Limitations of Atlassian Forge
While Atlassian Forge simplifies cloud app development and strengthens security, developers often encounter limitations, especially compared to Connect apps. Understanding these constraints is crucial before committing to the Forge platform for long-term projects.
Performance Limits
Forge operates on a serverless architecture (FaaS), meaning apps run within Atlassian Cloud with strict runtime limits:
- Standard function execution limit: Up to 25 seconds (applicable to all the interactions between the frontend and the backend).
- Async function execution limit: Up to 15 minutes (recent increase from 55 seconds, improving long-running operations).
- Storage performance limitations:
- Key-value storage: Simple but lacks transactional support and performs slower with large datasets.
- Entity storage: Better indexing and query capabilities but still evolving.
- RDBMS storage (EAP): Full relational database capabilities, but currently in Early Access Program.
- Forge Cache (EAP): Temporary fast storage, useful for caching but not persistent.
- Object Storage (EAP): Future support for handling large files and data blobs.
Key concern: Complex apps processing large datasets or requiring transactional consistency may hit performance bottlenecks. Developers often need batch processing or external APIs to handle data-heavy tasks.
Note
Developers moving their apps to Forge might face challenges migrating from relational databases to Forge storage. Large client data sets require careful architectural adjustments due to Forge’s storage limitations.
Learning Curve
Developers transitioning from Connect to Forge must adjust to serverless computing and Forge-specific APIs:
- Serverless execution model requires thinking in stateless, event-driven functions.
- Custom UI & UI Kit differ from traditional frontend development—UI Kit is restrictive but faster; Custom UI allows flexibility but requires mindful work with front-end and Forge Bridge API.
- Forge CLI is powerful but requires familiarity for tasks like deployment, log retrieval, and environment setup.
During app migration to Forge, developers might have to rethink data storage strategies and redesign certain features to align with Forge’s architecture.
Platform Instability & Active Development
Forge is rapidly evolving, which is both an advantage and a risk:
- Frequent updates: New modules, storage options, and performance improvements are released regularly.
- Stability concerns: Apps may break unexpectedly after Forge platform updates, requiring constant monitoring.
- Developer Dashboard limitations: Error tracking is still basic, and developers often rely on user-provided logs to diagnose issues.
Developers might experience instability during the initial migration of their apps to Forge. Frequent platform updates can cause intermittent failures, highlighting the need for close monitoring and rapid response when issues arise.
Future of Atlassian Forge & Roadmap
Atlassian Forge is continuously being developed, and new features and improvements are regularly released to enhance app performance, developer experience, and platform stability.
Key upcoming updates include:
1. Advanced Compute Capabilities:
Atlassian is expanding Forge’s compute capacity with support for long-running tasks (up to 15 minutes), multi-language runtimes via Docker containers, and a container service for serverless execution. These upgrades will empower developers to build more robust, resource-intensive applications while benefiting from automatic scaling and reduced runtime limitations.
2. Expanded Data Storage Solutions:
Forge is introducing new data storage options, including Forge Object Storage for large files and Forge SQL Service for structured relational data. These additions will help developers handle diverse data requirements directly within the Forge platform, removing the need for external storage workarounds.
3. Real-Time Functionality & Improved User Experience:
Upcoming features like Forge Real-time capabilities and UI Navigation Methods will enable developers to create more interactive, responsive applications with real-time updates and smoother in-app navigation. These enhancements aim to bring Forge’s UI flexibility closer to what’s possible with Connect apps.
4. Strengthened Security & Integration Controls:
Atlassian is refining egress management with No-egress Web Triggers and Analytics Egress Control (admin consent). These improvements ensure apps maintain strict data security standards while offering more controlled outbound request options. They align with Forge’s “Runs on Atlassian” eligibility standards, giving businesses greater confidence in data protection.
For detailed timelines and feature specifics, visit the Atlassian Forge Public Roadmap
Conclusion
Atlassian Forge changes the way teams build apps for Jira, Confluence, and other Atlassian products. It eliminates the hassle of setting up servers and worrying about security.
Developers can build apps faster because Forge runs everything inside Atlassian Cloud. Apps work smoothly with Jira, Confluence, and Bitbucket right out of the box. Security and data privacy are already built in. This is a big plus for companies that need to comply withstrict rules like GDPR.
Forge keeps getting better. Atlassian is working on faster app performance, more storage options, and better tools for customizing app interfaces.
Teams already using Connect apps will need to switch to Forge in the future. Starting now gives you a head start and ensures your apps are ready when Connect is phased out.
Get started with Forge, or check the Forge Roadmap for the latest updates.
