PM Engine FAQ

PM Engine is a self-hosted project management tool for teams that want ownership without legacy software complexity.

It runs on infrastructure you choose, so project data stays in your environment. Teams manage work through cards, projects, boards, and tags. Cards capture the work itself. Projects define scope. Boards move work through delivery. Tags add cross-cutting context without heavy configuration.

PM Engine is built for organizations that want a modern project management tool they can own for the long term. It combines the day-to-day simplicity people expect from SaaS with the autonomy of self-hosting.

PM Engine is built for small-to-mid organizations that treat project data and vendor independence as strategic concerns.

The best fit is a team with enough technical capability to run a self-hosted application. That might be a software company, IT team, operations group, agency, or business team with internal technical support. The common trait is not industry. It is the decision to keep important systems under your own rules.

PM Engine is not the right fit for teams that want a fully managed SaaS product and have no interest in hosting software. It is also not designed as a heavyweight enterprise project portfolio platform. It is for teams that want project management to stay simple while the system remains theirs.

It means PM Engine runs in your environment, keeps the product model clear, and leaves the operating decisions with you.

"Simple" means the product focuses on the core pieces teams need every day: cards, projects, boards, and tags. It avoids unnecessary process overhead and administrative layers that slow adoption.

"Self-hosted" means PM Engine runs on your own infrastructure or trusted cloud environment. Your team manages the application, data, backups, access policies, and update timing.

"Fully own" means the project management system remains part of your stack. You keep direct access to the data. You decide when to update. You are not forced into vendor-hosted infrastructure, vendor release schedules, or per-seat pricing pressure.

Jira, Asana, and Trello are vendor-hosted SaaS tools. PM Engine is self-hosted project management software.

That difference changes the long-term relationship. With SaaS tools, the vendor owns hosting, uptime responsibility, product changes, pricing structure, and terms for continued access. Those tools can be quick to adopt, and they may be the right choice when ownership is not a priority.

PM Engine is built for teams that want the project management system inside their own stack. Data stays in your environment. Updates happen on your schedule. Pricing is flat-rate by plan, not a fee that rises with every added user.

The practical difference is autonomy. PM Engine is a SaaS alternative for teams that want modern project management without renting a critical system from a vendor.

PM Engine is self-hosted, but it is not built like a legacy issue tracker or heavyweight project platform.

Tools like Redmine grew from older bug-tracking and technical project models. They can be useful, especially for teams that already know them, but many organizations pay for that autonomy with dated interfaces, steep learning curves, and more administration than they want.

OpenProject serves many structured, governance-heavy, and formal project environments. PM Engine takes a narrower path: modern project management for teams that want ownership, low operational burden, and a clean daily experience.

PM Engine focuses on cards, projects, boards, and tags. It is designed for people doing the work, not only for administrators, reporting layers, or formal project offices.

Choose self-hosted project management when ownership, data location, update timing, and long-term cost predictability matter.

SaaS tools are convenient, but they create dependency. The vendor sets the hosting model, release schedule, feature packaging, and pricing structure. A tool that looks inexpensive at 15 users can become expensive at 80. A redesign can arrive before your team is ready. A migration can become hard enough that leaving no longer feels realistic.

Self-hosting changes that structure. Project data stays where your organization decides. Updates happen when your team is ready. Integrations can use the API or direct database access without relying on vendor-governed limits.

Self-hosting still carries responsibilities. Your organization handles hosting, backups, and maintenance. PM Engine exists because that responsibility should not require accepting a dated, complicated tool.

PM Engine is designed for a quick, practical installation rather than a services-led deployment.

Installation options include native installers for Windows, macOS, and Linux. A technically capable team should treat PM Engine like a modern self-hosted application: download it, install it, connect it to the right environment, and start evaluating with real project data.

For a technically capable team, installation takes no more than five minutes. Download the installer, install it, connect it to your environment, and you are running.

The fastest path is to start with the free Starter Edition from the download page and test the product model before planning a wider deployment.

No dedicated DevOps team is required for a typical PM Engine deployment.

PM Engine is built for teams with light in-house technical capability. That usually means someone who can install and maintain a self-hosted application, manage basic infrastructure, configure access, and handle routine updates.

It is still self-hosted software. Your organization remains responsible for backups, uptime, server access, and internal policies. But PM Engine is intentionally designed to avoid the operational burden that makes older self-hosted tools practical only for large IT departments.

Yes. PM Engine offers a live demo and a free Starter Edition for evaluation.

The live demo shows PM Engine with sample projects, boards, and cards, so evaluators can see how the work model behaves before installing anything. It is the quickest way to understand the product structure.

The Starter Edition is free for up to 15 users. It is a real self-hosted installation, not only a time-limited trial. Use it to test PM Engine with your own data, deployment environment, and team process before deciding whether a paid plan makes sense.

Start with the live demo if you want to look around first. Start with the download if you want to evaluate PM Engine inside your own environment.

Support depends on the plan.

The Starter plan includes basic email support. The Professional plan includes priority email support for growing teams. Enterprise customers receive enterprise support aligned to their agreement.

All plans include the full PM Engine feature set, so support level is not used to split core functionality across tiers. The main differences are user limits, support expectations, and enterprise requirements.

For current limits, support details, and licensing terms, check the pricing page before purchase.

PM Engine is built by PM Engine Inc.

The product builds on more than 15 years of project management product experience through Scrum Mate, which has been in production since 2009. That history matters because PM Engine is not a first attempt at project management. Its model comes from years of building and maintaining tools for real teams.

PM Engine Inc. is backed by founders with a track record in developer infrastructure, including building /n software, a developer tools company focused on network communication, and founding CData Software, a data connectivity company. That background shapes the approach: build tools that technical teams can rely on, extend, and keep running for years.

PM Engine is built with a long-term ownership mindset. The goal is not to trap customers inside the product. The goal is to keep the tool useful, simple, and worth running.

Self-hosted project management software runs on infrastructure the customer controls. The application, the database, and all project data live in the customer's environment, not on the vendor's servers.

That is the core structural difference from SaaS tools like Jira Cloud, Asana, or ClickUp. With SaaS, the vendor manages hosting, uptime, backups, and releases. With a self-hosted tool, those responsibilities belong to the team running it. In practice, the team chooses where the application runs: a server they manage, a virtual machine on AWS, Azure, or GCP, or an on-premise system.

PM Engine is a self-hosted tool. Teams manage work through cards, projects, boards, and tags. Project data stays in the environment the team chooses. The vendor has no access to it.

Self-hosted project management gives teams two structural advantages over SaaS: data location control and update schedule control. It also supports a different cost model. Because the vendor is not running infrastructure for every customer, heavier usage does not create the same operating-cost risk for the vendor.

With SaaS, the vendor controls the operating model. They host the data, ship changes on their schedule, and set the pricing structure. That tradeoff can work at small team sizes, when the cost is low and the tool is easy to adopt. Over time, the dependency becomes more visible: per-seat pricing grows with the team, redesigns arrive on the vendor's timeline, and useful features can move behind higher tiers.

PM Engine changes that arrangement. Data stays in your environment. Updates happen when your team is ready. Pricing is flat-rate, so adding ten users within a plan tier doesn't trigger a new invoice.

The tradeoff is real: your team takes on hosting, backups, and maintenance. PM Engine exists to make those responsibilities practical rather than punishing.

Yes. PM Engine is designed for small-to-mid organizations without large IT departments.

The minimum requirement is one person who can install and maintain a self-hosted application: set up a server or virtual machine, configure access, and handle occasional updates. Most technical teams already have that capability without a dedicated operations role.

Self-hosting stops being practical when an organization has no in-house technical capability at all. If no one on the team has ever deployed a web application, the added responsibility of running PM Engine is likely not worth it. For teams with basic technical support, even if that's a part-time function, the operational load is manageable.

Download PM Engine and test it in your own environment. Installation takes about five minutes.

No dedicated IT team is required.

PM Engine is built for teams with light in-house technical capability. The operational load is intentionally low: install the application, configure access, apply updates periodically. No complex infrastructure to maintain. No specialized DevOps knowledge required for a standard deployment.

Self-hosted software does carry real responsibilities. Your organization handles backups, uptime, and internal access policies. Someone on the team needs to be able to administer a self-hosted application. But that person does not need to be a full-time systems administrator.

PM Engine installs from a native installer on Windows, macOS, or Linux. A technically capable person can have it running in under five minutes.

Yes. PM Engine runs on any infrastructure you control.

That includes virtual machines on AWS, Azure, Google Cloud, or DigitalOcean; on-premise servers in your own facility; or any cloud environment your organization manages. What matters is not where the hardware is located but that your team controls the environment, the data, and the access policies.

PM Engine does not require or recommend a specific cloud provider. Pick the infrastructure that fits your operational preferences, compliance requirements, or existing stack. The installation process is the same regardless of where you deploy.

Download the installer and test it in your environment.

Yes. Updates are controlled by the team running the installation.

PM Engine does not push automatic upgrades. When a new version is available, your team decides when to apply it. You can test the update in a staging environment first, schedule it for a low-activity window, and roll back if something unexpected happens.

That is a deliberate design choice. Forced updates have real costs: they can change interfaces your team depends on, introduce regressions, or arrive at the wrong time. With PM Engine, the update schedule belongs to the team, not the vendor.

Self-hosting changes the economics behind pricing. The vendor does not carry the same infrastructure cost as usage grows, so PM Engine can use flat-rate pricing instead of per-seat pricing.

The Starter plan is free for up to 15 users. Professional is $999 per year for up to 100 users. Enterprise pricing is customized for larger organizations. Adding users within a plan tier does not increase the annual cost.

SaaS tools typically charge per seat. At small team sizes that seems manageable. At 50 or 80 users, the same per-seat structure can cost significantly more than a flat-rate alternative, and the gap grows with every hire.

Self-hosting carries real operational costs: server infrastructure and occasional maintenance time. In most cases, those are modest and predictable. See the pricing page for full plan details.

SaaS is the better choice when an organization has no in-house technical capability, needs a fully managed service, or has no particular priority around data ownership.

If no one on the team can install and maintain a web application, self-hosting adds friction without a corresponding benefit. If vendor-managed hosting, automatic updates, and shared infrastructure are genuinely fine for the organization, SaaS tools are faster to start and carry no operational overhead.

PM Engine is not the right fit for every team. If data ownership, update timing, and pricing predictability are not priorities, a SaaS tool may be the better fit. The decision belongs to the team.

Routine PM Engine maintenance involves three things: applying updates, managing backups, and monitoring the server environment.

Updates are on your schedule. Applying a new version typically means running the updated installer or applying a package update. Backups depend on the database you use: SQLite creates a single portable file; PostgreSQL and SQL Server use standard database backup tooling. Server monitoring follows whatever practices the team already uses for other self-hosted applications.

There is no required configuration management, no vendor support tickets for infrastructure problems, and no approval process for changes. Manage PM Engine like other self-hosted software in your stack.

For teams already running any self-hosted application, the maintenance overhead will feel familiar.

Self-hosting means uptime is the customer's responsibility, not the vendor's.

That is a real tradeoff. A well-resourced SaaS service may offer higher-availability infrastructure than a small team can maintain. For teams with straightforward deployment needs and standard server practices, self-hosted reliability is typically adequate. For teams that need higher availability, PM Engine can run on a high-availability virtual machine from a cloud provider, or in configurations with redundancy and failover, depending on infrastructure choice.

The advantage is that you control the reliability variables: server location, hardware specs, backup cadence, and failover setup. SaaS reliability depends on the vendor's architecture, their incident response, and terms that can change.

Most teams that choose PM Engine decide that owning the uptime responsibility is preferable to accepting a vendor's SLA on the vendor's terms.

Full data ownership means your project data lives in your environment, under your control, with no vendor access.

PM Engine runs on infrastructure you manage. Cards, projects, boards, comments, history: all of it sits in the database on your server. PM Engine Inc. has no connection to that installation. The vendor can't read, access, or export your data.

Ownership also means you control when to update, when to migrate, and whether to stay on PM Engine at all. Move, back up, archive, or delete your data without asking for permission. Query it directly from the database. There's no vendor-controlled export API to depend on and no vendor-side process required to retrieve or delete your data.

This isn't a policy claim. It's a structural consequence of how PM Engine deploys.

Your project data is stored in the database on the server you choose. Not on PM Engine Inc.'s infrastructure.

By default, PM Engine uses SQLite, a single-file database that sits on the server your team manages. Enterprise deployments can use PostgreSQL or SQL Server. That server might be on-premise, or a virtual machine on AWS, Azure, GCP, DigitalOcean, or any cloud environment your organization controls.

File attachments and application data follow the same rule. They stay in your deployment environment. PM Engine Inc. does not operate a central data store. No project data passes through shared vendor infrastructure.

You decide where the server is, who can access it, and what backup policy to apply.

Only the people you grant access to in your PM Engine installation, and anyone with access to the underlying server.

Within the application, PM Engine includes user management and role-based access controls. Those settings determine which users see which projects, boards, and cards.

Below the application layer, access depends on who controls your server and database. Your organization manages that: server authentication, network policies, and database credentials are all under your control. PM Engine Inc. has no access to any customer's installation.

To audit who accessed what, query the database directly. The application logs also record user activity.

No. PM Engine is self-hosted software running on your infrastructure. No project data passes through PM Engine Inc.'s servers or any third-party vendor.

Because PM Engine runs entirely within your environment, no project data reaches any external system under normal operation. If you configure integrations with external services, such as email notifications, webhook targets, or external identity providers, those connections are set up by your team and subject to your own review.

PM Engine is self-hosted. There's no vendor-operated analytics infrastructure your installation connects to.

Because PM Engine runs on your own server, the vendor has no ongoing connection to it. Normal operation doesn't involve outbound calls to PM Engine Inc.'s infrastructure. There's no usage data reported back to the vendor and no licensing check that requires a continuous internet connection.

To verify this for your own deployment, your server's outbound network logs will show exactly what connections the application makes.

No. PM Engine runs on your local server and doesn't require an internet connection for normal operation.

Once installed, PM Engine serves its interface from your own environment. Users access it through your internal network or a connection you configure. The application doesn't depend on external services to function.

Email notifications and webhooks require outbound access to the services you've configured. Creating cards, updating boards, and managing projects all work without external connectivity.

Yes. PM Engine deploys in environments with no internet access.

There's no vendor connection required for the application to function. No licensing check, telemetry, or external service call is needed for normal operation. The application serves its interface entirely from your own server.

Email notifications and webhooks won't work in a fully isolated environment, but those are optional and configurable. Core project management runs without internet access.

Organizations with strict network isolation requirements, such as air-gapped data centers, classified environments, or facilities with outbound traffic controls, can evaluate PM Engine against their specific configuration requirements.

Yes. Self-hosting structurally eliminates the most common forms of vendor lock-in.

With SaaS tools, the vendor controls the data format, the export options, and the migration path. Switching depends on whatever export format they choose to provide.

PM Engine stores project data in a standard relational database. Starter and Professional plans use SQLite. Enterprise deployments use PostgreSQL or SQL Server. Query it directly, back it up in full, and migrate to a different system without vendor permission. The REST API also provides programmatic access to all project data.

PM Engine's design principle is that continued use should be earned through value, not enforced by dependency.

Yes. Because you choose the infrastructure, you control where the data is stored geographically.

PM Engine runs on whatever server or cloud environment your organization manages. If your requirements call for data to stay in a specific country or region, deploy PM Engine on infrastructure in that location. The vendor plays no role in the data location decision.

This matters for organizations subject to data residency requirements. PM Engine doesn't eliminate your compliance responsibilities, but self-hosting puts the data residency decision in your hands rather than in a vendor contract.

Confirm specific requirements with your legal or compliance team and select infrastructure accordingly.

Access it directly from the database. There's no vendor-mediated export process.

PM Engine stores all project data in the database on your server. Starter and Professional plans use SQLite, a single portable file. Enterprise deployments use PostgreSQL or SQL Server. Standard database tooling exports that data in full at any time. No vendor permission required, no export queue to wait on.

For application-level access, the REST API covers projects, boards, cards, and tags. Both paths are available simultaneously.

Because you control the server, you can also migrate PM Engine's entire database to a different server, clone it for archiving, or maintain a backup copy without involving PM Engine Inc. at any stage.

Your data stays with you. PM Engine doesn't delete or lock your project data when a license lapses.

PM Engine is self-hosted. Your project data lives in your database, on your server. PM Engine Inc. has no access to it and can't restrict or delete it remotely.

The application may eventually stop functioning normally if an expired license restricts application access. Check the specific terms at pmengine.com/pricing for current details. Your underlying data stays accessible directly from the database regardless of license status.

Your data doesn't exist on a vendor server that gets switched off when you stop paying.

PM Engine runs on Windows, macOS, and Linux. Native installers are available for all three platforms.

No platform-specific configuration is required after installation. Most self-hosted deployments run on Linux servers, but Windows and macOS are fully supported options for teams with different infrastructure preferences.

Requirements depend on team size and usage. For small-to-mid teams, PM Engine runs well on a modest server or virtual machine.

PM Engine is designed to stay lightweight. A team of 10-15 people runs comfortably on a single vCPU with 512 MB of RAM. Larger teams may need more, but the starting point is modest.

Yes. PM Engine deploys on any cloud provider where you can provision a virtual machine. Teams run it on DigitalOcean, Azure, Google Cloud, AWS, and any other hosting environment where you control the server.

The deployment process is the same regardless of provider: install the application, configure a mail server connection, and point your domain at the instance. What matters is that your team controls the server. The specific cloud provider is your choice.

Not for most deployments. PM Engine ships with SQLite support, which stores all data in a single file on the same server. No separate database server is needed for Starter or Professional plans.

Enterprise deployments support PostgreSQL and SQL Server. Use those when your organization needs database-level replication, automated failover, or when existing backup and recovery policies require a standalone database server.

SQLite is the right starting point for most teams and handles a significant volume of data without issues.

Move to PostgreSQL or SQL Server when you need database-level replication, automated failover, or when your organization's compliance and recovery requirements require a standalone database server. This transition is an Enterprise-tier capability.

If you are unsure, start with SQLite. It is simple to operate, and migrating later is a documented process. The decision to change databases should be driven by operational requirements, not assumption.

PM Engine has a built-in backup tool. It creates a .tar.gz archive containing the database (pmengine.db) and any file attachments.

Backups are your responsibility as the operator. That is the trade-off of self-hosting. The advantage is that the backup process, retention schedule, and storage location are entirely under your control. Detailed file paths and recommended backup approaches are in the help documentation.

You control when PM Engine upgrades happen. There are no forced updates. When a new version is available, you download it and apply it on your own schedule.

Typical upgrades require a brief maintenance window while the application restarts. The exact duration depends on your infrastructure.

PM Engine supports high-availability deployments when paired with a database that supports replication, such as PostgreSQL or SQL Server.

HA configuration details depend on your infrastructure design and the database you choose.

Migration is a standard self-hosted operation. Stop the application, move the database and configuration files to the new server, install PM Engine, restore your files, and restart.

No data is held on PM Engine's servers, so migration is entirely within your environment. You can move PM Engine to a different server, hosting provider, or region at any time without vendor involvement.