Before diving into what Plane is, let’s talk about why self-hosting remains a hot topic—especially when industry giants like Atlassian (makers of Jira) have sunset their on-premise offerings. Over the past few years, I’ve been active on countless forums, speaking with customers, prospects, and developers who all echo the same frustrations with fully cloud-based tools:

• Data Control
  They want full ownership of their data—where it’s stored, how it’s accessed, and who can see it.
• Customization
  One-size-fits-all just doesn’t cut it when your processes are unique. Teams need the ability to tinker under the hood.
• Cost Predictability
  Subscription fees can balloon as teams grow, making SaaS an expensive long-term proposition.
• GovCloud & Regulatory Requirements
  Many organizations, especially in the public sector or highly regulated industries, need GovCloud-ready or compliant infrastructure. Self-hosting allows them to meet strict security and data governance mandates that aren’t always feasible with pure SaaS solutions.

Jurisdictions like the European Union’s GDPR and India’s Data Protection Bill mandate that certain data types remain within national borders. Self-hosting enables compliance by ensuring data never leaves corporate servers. A German automotive manufacturer avoided €2 million in potential GDPR fines by switching to a self-hosted ERP system with localized data storage.

Yet, despite this very real demand, Atlassian decided to retire its self-hosted Jira Server and push customers toward its Cloud offerings. Is self-hosting just too hard to maintain at scale? Or did they simply decide it’s more profitable to centralize everything in the cloud?

Interestingly, Atlassian’s own Q1 2024 forecasts reveal that their Data Center (on-prem) offerings are **expected to outpace cloud revenue growth**—even though they’re aggressively steering users toward their cloud products. They’ve also introduced **minimum seat requirements** for Data Center, leaving smaller teams or heavily regulated customers with fewer on-premise options. Clearly, the demand for self-hosted solutions hasn’t faded—if anything, Atlassian’s financial data suggests it’s still going strong.

The truth is likely somewhere in the middle. Large incumbents often prioritize predictable revenue streams and streamlined support. Maintaining on-premise tools—with all the variations in OS, network configurations, and third-party integrations—can be complex. But for many organizations—from heavily regulated industries to indie dev teams—this is exactly what they want: freedom and control, even if it means handling infrastructure themselves.

So, if self-hosting has “scared off” some big players, how is a small startup like Plane thriving in this space?

It comes down to our commitment to open-core from day one. We’ve always believed in putting users in control of their data and workflows—so when our community pushed for self-hosting, we embraced it wholeheartedly. We were built for open collaboration right from the start, and that foundation made it natural for us to expand into robust self-hosting options.

That’s exactly why we believe we’re winning in the self-hosted project management category- we didn’t tack it on after the fact, but rather grew into it from our open-source roots. 

And for those who don’t want to manage their own infrastructure, our **Cloud** offering maintains **full feature parity** while also being **SOC 2 Type 2**, **GDPR**, **HIPAA**, and **ISO** compliant—so you can rest assured your data is secure.

Why We Prioritized Self-Hosting at Plane

In our early days, our main goal was to open-source the entire Plane project. To be honest, self-hosting was more of an afterthought at first. For nearly a year, we didn’t focus on sustainability, because every conversation with users revolved around feature parity:

• “Jira has automations; does Plane have them?”
• “Monday.com has templates; does Plane have them?”

We poured our energy into building out core features, ensuring that Plane could stand toe-to-toe with established tools. But since our code was open by default, the community naturally started self-hosting Plane for their own organizations. Soon, requests poured in asking us to make self-hosting easier and more robust.

Rather than dive into the technical details of our infrastructure, I’ll simply mention that we wrote a blog post about how we scaled to 500K+ Docker pulls in less than a year. That milestone confirmed both the demand and our ability to deliver a self-hosted solution at scale.

With all this traction—and no single player truly dominating the self-hosted project management space—we decided that whatever we build, we’d always ensure full parity between our cloud and self-hosted offerings.

The Challenges of Being a Young Startup Committed to Self-Hosting

Embracing self-hosting from day one isn’t easy, especially for a small team. Here’s why:

• Every Setup Is Different
  Self-hosting Plane isn’t the same on AWS, Heroku, Coolify, or a custom server. Each environment introduces its own quirks, dependencies, and troubleshooting scenarios.
• Multiple Deployment Options
  We support Docker, Helm charts (for Kubernetes), and local installations. Maintaining all these deployment methods adds complexity, but it’s essential for meeting users where they are.
• Air-Gapped Solutions
  Some organizations require fully offline or heavily restricted network environments (e.g., government agencies). Ensuring Plane functions smoothly in these scenarios demands extra configuration and testing.
• Community vs. Commercial
  Balancing open-source freedom with commercial sustainability is a constant challenge. With the entire codebase accessible, how do we prevent misuse of licenses or differentiate premium features? We rely on careful feature flagging, transparent licensing, and a clear open-core model.

Despite these hurdles, we’ve found that doubling down on self-hosting has galvanized our community and set us apart from competitors who either abandoned on-premise or never offered it in the first place. As Plane evolves, we remain committed to maintaining feature parity, because we believe in giving teams true freedom of choice—without compromising on the user experience.

The Start: Introducing Plane One—A One-Time Perpetual License

Almost a year into our journey, we introduced our first plan—and in a rather unconventional way. Rather than rolling out a new cloud tier, we launched a purely self-hosted plan called Plane One, offered as a one-time perpetual license (now set to sunset on March 14th, with a year of support).

Why take this route? Sustainability. We saw growing demand for enterprise-grade features—time tracking, OIDC, SAML, bulk operations, and more. Plane One provided these capabilities without compromising our core community edition, while also helping us fund continued development of an open-core platform.

Mixed Reactions from the Community

Reactions were split. Some welcomed Plane’s move toward enterprise support, while others worried about monetization and wanted everything fully open-source. Ultimately, though, we needed a model that would let us grow sustainably and keep improving Plane over the long haul.

Laying the Foundation for Enterprise Self-Hosting

While Plane One wasn’t an overnight success, it taught us valuable lessons about on-premise architecture, subscriptions, and instance governance. We experimented with internal tools for license management, instance health monitoring, and automated setup—efforts that would later evolve into more mature solutions for our broader commercial offerings.

This balanced approach—offering advanced features in a paid tier while maintaining a robust community edition—set the tone for our open-core philosophy going forward. Instead of diluting either version, we aimed to meet users where they are: if you need advanced, enterprise-level functionality, it’s available; if you just want solid, open-source basics, that’s there too.

Plane One planted the seed for everything we’ve built since, proving that self-hosting can thrive when you combine feature parity with an easy deployment experience—and giving us the confidence to keep self-hosting at the heart of Plane’s evolution.

How we Scaled—and Continue Scaling

Plane One turned out to be a big success, helping us hit six figures in revenue and proving that a self-hosted monetization model could work. Early on, we supported only Docker setups, but as our user base grew, we added Kubernetes (K8s) deployment options. Huge thanks to our customers for being patient during those early days of rapid iteration. While we had our fair share of support challenges, we managed to pull it off.

Enter Our Commercial Edition

Once Plane One proved successful, we set our sights on developing more robust commercial offerings: the Pro and Business plans. Both still build on our open-source foundation, ensuring that core functionality remains consistent across editions.

Meanwhile, our cloud user base was also growing at a rapid pace. Shipping new features to the cloud was straightforward—write code, deploy, repeat. But juggling rapid feature releases for both cloud and self-hosted editions quickly evolved into a two-front challenge: we needed to maintain feature parity, handle diverse infrastructure requirements, and keep everything in sync without overburdening our small but dedicated team.

Here’s how we handled it:

• Managing Speed
  We release features to our cloud version first, then follow with a 15-day delay for our self-hosted edition. This cushion ensures new features are stable and thoroughly tested before rolling them out to on-prem customers.
• Billing & Plans
  We integrate with Stripe for both cloud and self-hosted licensing. Having a unified billing approach gives us visibility across the board, whether someone’s using our hosted solution or running Plane on their own infrastructure.
• Introducing “Disco”
  To streamline licensing, we built Disco as a bridge between Stripe and our Prime Portal. When a customer purchases a One, Pro, or Business license, Disco securely registers only the essential admin details for that instance—no unnecessary personal data. It then generates a license key that unlocks the relevant feature flags on the self-hosted deployment. By keeping data collection minimal, we ensure both convenience and privacy for our users.
• Migrating from Heroku to AWS
  As our user base demanded more integrations (GitHub, GitLab, Slack, etc.), we built SILO—our integration service that needed more control and configurability than Heroku allowed. Moving to AWS gave us the freedom to manage services at a granular level, mirroring the experience our users have on their own Docker or K8s setups.
• Easier Upgrades
  We also simplified the upgrade path between editions. Users can start with the Community Edition and, when they’re ready, upgrade to Pro or Business without re-installing or losing data. A few commands (and a new license key) is all it takes.

Taken together, these steps ensure our self-hosted customers enjoy almost the same convenience and velocity as our cloud users. Yes, it’s an ongoing endeavor—every new feature or integration adds complexity to both sides. But by carefully managing releases, centralizing billing, and standardizing deployment practices, we’re able to deliver a powerful, evolving platform that satisfies a wide range of team sizes, compliance needs, and technical environments.

Our Technical Architecture & Timeline

1. Foundation: Django & Next.js

From day one, Django has powered our backend, offering a robust Python framework known for rapid development and scalability. On the frontend, we chose Next.js for its modern React-based architecture and server-side rendering capabilities. Whether deploying via Docker or Kubernetes (K8s), these core technologies remain the bedrock of Plane’s stack.

2. Building on top of our Community Edition

• Until Early 2024: We focused exclusively on stabilizing Plane’s community edition—100% of the code was open-source, and our priority was delivering essential PM features (boards, issue tracking, sprints, etc.).
• Post-Early 2024: We began building our commercial edition. Our philosophy? Keep fundamentals in the community version, and place speed-boosting, advanced features in the commercial edition. This approach helps us serve a broad range of teams without diluting the open-source foundation that started it all.

(We strive to be considerate in how we separate these features, ensuring the community version remains robust while the commercial edition caters to those needing advanced, specialized functionality.)

3. Building Our Own Feature Flagging

As soon as we decided on a commercial product, the first hurdle was feature gating:

• Forking the Repo: We maintain a separate repository (nicknamed plane-ee) that builds atop the community code. This lets us merge improvements in both directions without conflicts.
• OpenFeature Integration: After testing various third-party solutions, we created our own feature-flagging service based on OpenFeature. This custom setup seamlessly supports both Plane Cloud and self-hosted instances, toggling commercial features only for licensed users.

4. Introducing Licensing & Prime Portal

Next, we needed a seamless way for customers to buy and deploy the commercial edition:

• Prime Portal: A web interface for customers to manage subscriptions, track instance health, and generate license keys.
• Disco: Our internal licensing system that integrates with Stripe. When a customer purchases Pro or Business, Disco issues a license key mapped to specific feature flags in our commercial code.
• Prime CLI: Bundled with plane-ee, it prompts users for their license key during installation, enabling the correct feature flags.

5. Connectivity & Verification

Each Plane instance “phones home” at least once every three days:

• License Validation: This check ensures your subscription is active and flags any suspicious activity.
• Minimal Data Exchange: Only essential info is passed, keeping your data private while allowing us to confirm license status.

6. Infrastructure Scaling: Heroku to AWS

As we added integrations (GitHub, GitLab, Slack, etc.), we outgrew Heroku’s more managed environment:

• AWS Migration: Gave us finer control over services, matching the same Docker/K8s approach used by many self-hosted teams.
• SILO: Our dedicated integration layer now deploys seamlessly on AWS, mirroring what our self-hosted customers set up in their own environments.

7. Upgrades & Continuous Development

We know teams evolve over time, so we’ve tried to make upgrading from our Community Edition to Pro/Business as straightforward as possible:

• Minimal Re-deployment
  Although it’s not a simple matter of entering a license key, you don’t have to reinstall Plane from zero. Instead, you take a backup (using our well-documented scripts) and restore it in the commercial edition. This ensures your existing data and configurations carry over, without forcing a complete rebuild.
• Synchronized Releases
  While we often roll out new features to Plane Cloud first, we maintain a short delay before shipping them to self-hosted instances. That extra buffer helps us validate stability and performance, ensuring you get the best possible experience once it’s released.

By structuring our architecture around Django, Next.js, and a forked codebase with a custom feature-flagging and licensing system, we’ve built a foundation that supports both open-source enthusiasts and enterprise-level teams. If there’s anything you’d like to dive deeper into, let us know. We’re always happy to elaborate on how each component works—or how we keep everything in sync across our cloud and self-hosted worlds.

Conclusion: What’s Next for Plane?

Our journey hasn’t been linear. We started out trying to match feature parity with the giants, only to realize the self-hosted market was craving an open-core solution that balanced community ideals with commercial sustainability. By embracing self-hosting early, we leaned into our strengths: flexibility, transparency, and true data ownership.

Today, we’re proud to say we serve a diverse user base—from indie dev teams to heavily regulated industries—all of whom value the freedom that Plane offers. And for organizations who prefer a managed service, our Cloud edition provides the same features without the overhead of self-hosting.

But we’re far from finished. Our roadmap includes:

• Enterprise-Grade Features
  We’re focusing on Granular Access Controls (GAC), SLAs, workflows, and automations—the kind of robust functionality large organizations rely on.
• AI Models & Agents
  We’re exploring ways to deliver on-premise AI solutions so teams can reap the benefits of machine learning without sacrificing data sovereignty or compliance.
• Enhanced Scalability
  Simplifying the deployment and management of Plane for thousands of users across multiple regions—whether self-hosted or in our Cloud.

We believe there’s a bright future for self-hosted project management—one where teams can shape their workflows without being locked into one-size-fits-all SaaS. If you’re curious, we invite you to try Plane, open an issue on GitHub, or join our community channels to share your thoughts. We’re building this together, and we can’t wait to show you how we’re pushing the boundaries of on-premise innovation.