ProcessWire

Open-source content management, honestly reviewed. No marketing fluff, just what you get when you self-host it.

TL;DR

• What it is: Free, open-source PHP CMS and framework that lets developers build any kind of website without imposing opinions about structure, markup, or page types [README][website].
• Who it’s for: PHP developers and web agencies building custom sites for clients; technical founders who want total control over content architecture without the bloat of WordPress or the cost of Craft CMS.
• Cost savings: Webflow runs $23–$39/mo per site with CMS lock-in. Contentful Pro starts at $300/mo. ProcessWire runs on a $5–20/mo VPS with zero per-site licensing fees and no vendor lock-in [website].
• Key strength: The API. Every developer who switches to ProcessWire mentions this first. Content is never more than one line of code away, and the selector system for querying pages reads almost like natural language [README][website].
• Key weakness: Not for non-developers. There’s no visual page builder, no drag-and-drop theme system, and no meaningful plugin ecosystem compared to WordPress. You need a developer to build the front end [1][2][3].

---

What is ProcessWire

ProcessWire is a PHP CMS and application framework. You install it on a web server, define your content structure using custom fields, build your templates in plain PHP, and query everything through an API that the project itself describes as “a joy to develop with” [README].

What makes it different from WordPress, Drupal, and Ghost is the absence of assumptions. ProcessWire doesn’t impose a “posts and pages” model, doesn’t bundle a theme system with opinionated markup, and doesn’t ship with a plugin ecosystem designed to be sold to you. It gives you a hierarchical page tree, a field type system, a role-based access control layer, and an API — and then gets out of the way. You write the PHP templates that produce the HTML [README][website].

The project has been around longer than most people realize. It started in 2003, got the ProcessWire name in 2006, and has been maintained as open source since 2010 — that’s over 15 years of active development under a single maintainer, Ryan Cramer [README]. New versions ship “just about every week on the development branch” [README], which is a remarkable cadence for a project of this size. GitHub shows 1,054 stars — low compared to WordPress or even Ghost, but ProcessWire has never chased popularity. The README is upfront about this: “We don’t make a lot of noise, we’re not into promotion, we value quality over quantity, sustainability over growth” [README].

That philosophy shows in the product. ProcessWire sites are hard to identify from the outside — no generator meta tags, no default markup fingerprints — which is either a selling point (your site looks like yours) or a warning sign (if the developer leaves, you’re on your own reading their PHP templates).

---

Why people choose it

The pattern across comparison reviews is consistent: developers come to ProcessWire after hitting the ceiling on WordPress [1][2][3].

Versus WordPress. WordPress is the obvious incumbent. It runs 43% of the web, has tens of thousands of plugins, and you can get a non-developer up and running in an afternoon. But for developers building custom client sites, WordPress becomes weight: the theme/child-theme system is awkward, ACF or similar plugins are needed to get proper custom fields, the query layer is verbose, and plugin conflicts are a rite of passage. ProcessWire’s custom fields are native, not bolted on. The query API is clean. There’s no legacy code debt going back to 2003 (WordPress era) fighting with modern PHP. Developers who use both consistently describe ProcessWire as faster to develop against, easier to maintain long-term, and far simpler to secure [1][README].

Versus Drupal. The comparison is apt: both are developer-first PHP CMSes built for complex, custom content needs. Drupal wins on raw ecosystem size — thousands of contributed modules, a large talent market, enterprise adoption [2]. ProcessWire wins on simplicity. Drupal’s configuration management, hook system, and module architecture are powerful but impose real learning overhead. ProcessWire’s hooks system is more intuitive, the admin is less dense, and you’re not managing a framework-within-a-framework. For teams that don’t need Drupal’s enterprise feature set, ProcessWire is considerably more pleasant to work with [2].

Versus Ghost. Ghost is purpose-built for publishing — it’s excellent for newsletters, blogs, and membership monetization. It does those things well and is not designed to do much else [1]. ProcessWire has no CMS niche. It can manage a blog, a portfolio, a product catalog, a real estate listing site, or a 2-million-page archive (one reviewer on the official website manages exactly that). If your content model is “articles by authors with subscriptions,” use Ghost. If your content model is anything else, ProcessWire is a candidate [1][README].

Versus ExpressionEngine. ExpressionEngine and ProcessWire occupy nearly the same conceptual space: developer-first, flexible content structure, clean templating [3]. ExpressionEngine is commercial software; ProcessWire is free. ExpressionEngine has a larger legacy install base; ProcessWire has more active development. For new projects, the free-and-open argument for ProcessWire is compelling [3].

Versus Craft CMS. Craft (not in the source articles but frequently compared in the community) is the closest philosophical sibling — also developer-first, also custom fields, also clean API. Craft costs $299/year for the Pro license and $59/year per additional site. ProcessWire is free. For agencies building many client sites, that arithmetic adds up fast.

The testimonials on the ProcessWire website are consistent with this developer-affinity narrative:

“I am currently managing a ProcessWire site with 2 million+ pages. It’s admirably fast, and much, much faster than any other CMS we tested.” — Nickie, web developer [website]

“Building with ProcessWire was a breeze, I really love all the flexibility the system provides. I can’t imagine using any other CMS in the future.” — Thomas Aull, web developer [website]

These are developer voices, not marketing copy. Non-technical users are largely absent from this conversation, which is itself data.

---

Features

Content modeling:

• All fields are custom fields — text, image, file, date, relationship, rich text, and more [website]
• Repeater fields bundle fields into repeatable groups (think flexible content blocks without a page builder) [website]
• Hierarchical page tree with no depth limits — one site with millions of pages works the same as one with fifty [website]
• Pages are the universal unit — blog posts, products, users, and sections are all “pages” with fields attached [README]

Developer API:

• Selector-based query system: $pages->find("template=product, price<50, color=blue") [README][website]
• Everything accessible with one line of code regardless of content complexity [website]
• Hooks system that lets you intercept and modify any method in the core — no “plugin API” versus “core API” distinction [website][README]
• All markup is written by the developer in plain PHP templates — ProcessWire never touches your HTML [README][website]
• PHP 8.x compatible, actively maintained

Multi-language:

• Multi-language support is built into the core, not a plugin [website]
• Multi-language fields, URLs, and translation tools included [website]
• One of the few CMSes where language handling doesn’t require a third-party module

Security and reliability:

• “For more than 15 years, security has always been a central focus” [website]
• Designed to be left without updates for years if needed without becoming a liability — the README makes this claim explicitly: “you can launch a ProcessWire site and then leave it for years without maintenance or updates” [README]
• Role-based access control with granular permission scenarios [website]

Admin interface:

• Front-end editing (double-click any text or image on the site to edit it directly) [website]
• Clean, consistent admin UI — multiple comparison reviews cite the administrative interface as a strength [1][2][3][4]

Modules (plugins):

• Module system covers the expected: form builders, SEO tools, caching, e-commerce [website]
• Notable modules include Form Builder PRO (paid), Tracy Debugger (development tool), and ProcessChangelog [website]
• The module ecosystem is much smaller than WordPress or Drupal — breadth is not ProcessWire’s game

REST API:

• Canonical feature in the merged profile, available via modules rather than core [merged profile]

---

Pricing: SaaS vs self-hosted math

ProcessWire is free. There is no licensing fee for the software itself, no cloud tier, no per-site cost. You host it on your own server.

What self-hosting actually costs:

• VPS: $5–20/month (Hetzner, DigitalOcean, Contabo)
• Domain: $10–15/year
• SSL: free via Let’s Encrypt
• ProcessWire license: $0

Optional paid modules:

• Form Builder PRO: paid, price not publicly listed on the website
• Other commercial modules: available through the ProcessWire module directory, priced individually [website]

The comparison that matters for this audience:

Platform	Monthly cost	Content limits	Vendor lock-in
Webflow CMS	$23–39/mo per site	2,000–10,000 items	High
Contentful Pro	$300+/mo	API call limits	High
Craft CMS Pro	~$25/mo (annual)	None	Low
ProcessWire (self-hosted)	$5–20/mo VPS	None	None

For an agency running 10 client sites on Webflow, that’s $230–$390/month in perpetual SaaS fees. Migrating those to ProcessWire on a $20/mo VPS eliminates $210–$370/month — roughly $2,500–$4,400/year.

The honest caveat: getting to that number requires development work. ProcessWire isn’t a template-install CMS. The savings are real, but they assume a developer builds and maintains the sites. For a non-technical founder, the self-hosting cost also includes either learning PHP deployment or paying someone who already knows it.

---

Deployment reality check

ProcessWire deploys on any shared hosting, VPS, or cloud server that runs PHP and MySQL — meaning it works on infrastructure from 2010. The installer is a web-based wizard: upload the files, visit the URL, follow the prompts [README].

Minimum requirements:

• PHP 7.4+ (8.x recommended)
• MySQL 5.6+ or MariaDB
• Apache or nginx with mod_rewrite (or nginx rewrite rules)
• Any hosting that runs PHP — even shared hosting on Bluehost or SiteGround

What you actually need for a production site:

• A VPS with at least 1GB RAM (512MB will run it, 2GB is comfortable)
• nginx or Apache configured with SSL (Caddy is easy for non-sysadmins)
• MySQL or MariaDB
• A domain name

No Docker required. This is notable. ProcessWire predates the Docker era and installs like a traditional PHP app. That’s either a feature (simple, familiar to PHP developers) or a limitation (no 12-factor app configuration, not cloud-native by default). For a developer comfortable with traditional LAMP/LEMP stacks, deployment is genuinely easy — under an hour. For someone who has only done Docker-compose installs, the traditional PHP deployment model requires a different skill set.

Upgrading: Upgrading ProcessWire has historically been straightforward — replace the /wire/ directory with the new version. Major version upgrades have a documented migration guide [README]. This is a real advantage over WordPress, where plugin-induced upgrade failures are common.

Where it gets hard: ProcessWire requires a developer to build anything. Installing the CMS is easy. Building a site with it is a development project, not a “choose a theme” exercise. If you don’t have PHP knowledge or a developer on retainer, you’ll hit this wall immediately. The comparison articles note that ProcessWire’s learning curve is steeper than drag-and-drop builders [1][2][3] — that’s underselling it. It’s not just steeper; it’s a different category of tool entirely.

---

Pros and cons

Pros

• The API is genuinely excellent. The selector syntax for querying content is clean, intuitive, and powerful. Developers who’ve used it consistently describe it as one of the better CMS APIs they’ve worked with [README][website testimonials].
• Zero vendor lock-in. Your data lives in MySQL, your templates are plain PHP files, and the software is free. You can move hosts, migrate to a different server, or fork the code without permission from anyone [README].
• Scales unexpectedly well. A 2-million-page site running on ProcessWire is cited on the official website. The hierarchical page tree doesn’t impose practical limits [website].
• Multi-language in the core. Not a plugin, not an afterthought — built in from the start [website].
• Security track record. 15+ years of active security focus with no major CVE headline moments [website]. Compare to WordPress’s constant plugin-security news cycle.
• Traditional PHP deployment. Works on shared hosting. No Docker, no Kubernetes, no container registry. A developer can deploy it in an hour on any PHP host [README].
• Leave it alone for years. The claim that you can launch a site and not touch it for years without it becoming a security liability is credible given the track record [README]. This matters for agencies building sites for clients who go quiet.
• Free, including commercial use. No per-site license, no agency tier, no seat count [website].

Cons

• Not for non-developers — at all. There is no visual page builder, no theme system, no “install a plugin and have a store” experience. If you can’t write PHP, you cannot build a ProcessWire site without hiring someone who can [1][2][3].
• Small module ecosystem. Compared to WordPress (60,000+ plugins) or Drupal (thousands of modules), the ProcessWire module directory is thin. If you need a specific integration (CRM, payment gateway, analytics), you’re writing it yourself or adapting existing code [website].
• 1,054 GitHub stars. This is a low number. It means a smaller talent market for developers who know ProcessWire, fewer tutorials, fewer StackOverflow answers, and a narrower community to draw support from [merged profile].
• Documentation density. Multiple comparison reviews flag that while documentation exists, it’s dense and can be hard for newcomers [1][2][3][4]. The API reference is thorough but doesn’t hold your hand.
• No headless/API-first by default. REST API is available via modules, not native in the core [merged profile]. If you need a proper headless CMS with a robust content API for a React/Next.js frontend, tools built API-first (Directus, Payload, Strapi) are better choices.
• Single maintainer risk. ProcessWire is built by Ryan Cramer. The project is healthy and has been for 15+ years, but it’s not a foundation-backed project with organizational continuity guarantees. This is worth noting for long-term infrastructure decisions.
• No managed hosting option. There’s no “ProcessWire Cloud” if you decide self-hosting is too much. You’re on your own with the infrastructure, or you find a PHP host and manage it yourself.

---

Who should use this / who shouldn’t

Use ProcessWire if:

• You’re a PHP developer or web agency building custom sites for clients and you’re tired of fighting WordPress’s architecture.
• You need to model unusual content structures — event listings, real estate, directories, custom apps — where WordPress requires ACF + custom post types duct-taped together.
• You’re building multiple client sites and the annual Craft CMS licensing cost compounds into real money.
• You want a CMS that will run quietly without maintenance emergencies for years at a time.
• Multi-language is a requirement from day one.

Skip it (use WordPress) if:

• Your client needs to install plugins themselves to add functionality, or needs a large third-party theme ecosystem.
• You need a non-developer to build or maintain the site without ongoing developer involvement.
• You need specific integrations (WooCommerce, membership systems, LMS) that have mature WordPress plugins with no ProcessWire equivalent.

Skip it (use Ghost) if:

• The site’s entire purpose is publishing: newsletter, blog, membership. Ghost does that one thing better than any general-purpose CMS.

Skip it (use Directus, Strapi, or Payload) if:

• You need a headless CMS with a production-ready REST or GraphQL API for a React/Vue/Next.js frontend. ProcessWire’s API module works but wasn’t designed for this use case.

Skip it (use Webflow) if:

• The person building and maintaining the site isn’t a developer. Webflow’s drag-and-drop editor is the right tool when “no coding” is a real constraint.

---

Alternatives worth considering

• WordPress — the unavoidable comparison. Bigger ecosystem, worse developer experience, more security noise. Use it when ecosystem breadth or non-developer maintenance matters more than clean architecture.
• Craft CMS — the closest philosophical match: developer-first, custom fields, clean API. Commercial license ($299/yr Pro), better headless story, stronger commercial support options. Choose Craft if budget is not the constraint.
• Drupal — same PHP heritage, much heavier. Justified for large enterprise projects with complex workflows, access control hierarchies, or large development teams [2]. Overkill for most sites.
• Ghost — purpose-built for publishing and newsletters. Faster to launch for editorial use cases, weaker for anything beyond content publishing [1].
• Directus — headless-first, built around a REST/GraphQL API with a visual admin. Better choice for API-first architectures where the front end is a JavaScript framework.
• Grav — another flat-file PHP CMS in roughly the same niche: developer-friendly, no database required. ProcessWire is more powerful for large or relational content structures; Grav is simpler for smaller sites.
• SilverStripe — another developer-first PHP CMS/framework. Supports REST and GraphQL APIs natively, which ProcessWire doesn’t [4]. More enterprise-oriented, smaller community.

---

Bottom line

ProcessWire is the correct answer to a specific question: “What do I build a custom PHP-backed website on if I don’t want WordPress’s baggage and can’t justify Craft’s license?” For that audience — PHP developers and agencies building custom content sites — it’s genuinely excellent. The API is as good as advertised, the stability record is real, the zero-licensing-cost model removes per-site friction for agencies, and the ability to deploy it on any PHP host without containerization is a practical advantage.

The honest constraint is that ProcessWire requires a developer. It is not a tool for non-technical founders to manage themselves, not a theme-install experience, and not a headless CMS with a polished API surface. If those are your requirements, this is the wrong tool regardless of how clean the PHP API is. But if you have PHP development resources and you’re building something where content structure shouldn’t be a fight, ProcessWire has been quietly doing this job well for fifteen years — and that track record is worth more than the star count suggests.

If deploying and maintaining PHP infrastructure is the blocker, that’s exactly the kind of setup work that upready.dev handles for clients. One-time fee, running in production, you own the server.

---

Sources

1. AppMus — Ghost vs ProcessWire Comparison (2026) https://appmus.com/vs/ghost-vs-processwire
2. AppMus — Drupal vs ProcessWire Comparison (2026) https://appmus.com/vs/drupal-vs-processwire
3. AppMus — ExpressionEngine vs ProcessWire Comparison (2026) https://appmus.com/vs/expressionengine-vs-processwire
4. AppMus — ProcessWire vs SilverStripe Comparison (2026) https://appmus.com/vs/processwire-vs-silverstripe
5. AppMus — ProcessWire vs Pimcore Comparison (2026) https://appmus.com/vs/processwire-vs-pimcore

Primary sources:

• GitHub repository and README: https://github.com/processwire/processwire (1,054 stars, active since 2010)
• Official website: https://processwire.com
• Documentation: https://processwire.com/docs/
• API reference: https://processwire.com/api/ref/
• Module directory: https://processwire.com/modules/