Skip to main content
Capell home
Live demo

Keep the CMS inside Laravel without rebuilding every CMS contract

Custom Filament gives you complete control but makes your team build and maintain page types, URLs, preview, history and recovery. A separate CMS brings its own runtime and delivery boundary.

Capell provides a maintained Laravel foundation: editors work in Filament, your application renders the site, and each architecture decision below names its trade-off and evidence.

I built Capell around the point where a small custom admin becomes a permanent maintenance contract: pages need history, recovery, and a public boundary that stays legible.

A cutaway of the Capell platform showing content records, Filament editing, public delivery, package ports, and cache evidence.

Capell keeps publishing inside the Laravel application and gives every page a history you can go back through. The public site stays with the team that builds it.

Test the real CMS after the first launch

Capell records Page changes because client work rarely fails at the neat moment a CMS comparison table describes.

The other path

The Capell path

  1. Friday, 4:55pm

    The other path

    A rushed edit replaces the last known-good Page and leaves the team comparing screenshots.

    The Capell path

    The save becomes another Page event, so the earlier state remains available.

  2. Who approved this?

    The other path

    Chat logs and memory become the audit trail.

    The Capell path

    The Page history records the sequence; Publishing Studio adds reviewer assignment and approval.

  3. Roll it back

    The other path

    Recovery means reconstructing content or restoring more data than the Page that changed.

    The Capell path

    Preview the Page diff, validate the target state, then restore or roll forward.

  4. Upgrade day

    The other path

    Project-specific glue turns framework updates into archaeology.

    The Capell path

    Installer, upgrade and doctor commands keep the lifecycle explicit and testable.

  5. Handover a year later

    The other path

    The next developer inherits conventions that exist only in the previous developer's memory.

    The Capell path

    Page, layout, package and public-rendering boundaries remain visible in the Laravel codebase.

Keep the smaller path when

  • The site has a few stable pages.
  • The existing CMS already fits the team.
  • A separate content service is a firm requirement.

Choose Capell when

  • Publishing risk belongs inside the Laravel application.
  • Repeated Page families should improve together.
  • Upgrade and recovery work needs a shared contract.

See controlled publishing in practice

Every Capell site gets drafts, preview, Page History and restore. Publishing Studio adds approvals, assignments and coordinated releases.

01

Draft workspace

Edit the Page in a structured Filament workspace while the public version stays unchanged.

02

Review and approval

Preview the real Page and inspect the proposed change before making a publishing decision.

03

Controlled publication

Release the approved Page through the workflow available to that Capell installation.

04

Page history and rollback

Read the Page history, compare states, and restore a validated earlier version when needed.

Decision ledger

Trace the architecture decisions that make Capell different

Six closed decisions explain what Capell optimises for and what it deliberately gives up.

We kept the CMS inside the application on purpose. Each decision is useful only when its trade-off also fits your project.

  1. D-01

    Keep the CMS coupled to the Laravel application on purpose.

    Given up
    One content service feeding unrelated applications.
    Wrong for you if
    A delivery API is a fixed requirement.
    See how pages are delivered
  2. D-02

    Record every Page change as another event; never overwrite its history.

    Given up
    The simplicity of overwriting one current row.
    Wrong for you if
    Page-level history adds no operational value.
    Follow the publishing workflow
  3. D-03

    Add capability through reviewed Laravel packages, not anonymous plugins.

    Given up
    One-click anonymous installation.
    Wrong for you if
    Composer review and deployment ownership are unwanted.
    See how packages extend Capell
  4. D-04

    Use a Filament workspace for editors without maintaining a bespoke admin system.

    Given up
    A bespoke admin design system.
    Wrong for you if
    Your editors cannot work in Filament.
    Read the Filament CMS comparison
  5. D-05

    Make installation, upgrades and diagnosis explicit commands that teams can test.

    Given up
    Hiding lifecycle work behind a hosted control plane.
    Wrong for you if
    Your team will not own Laravel operations.
    Read the upgrade guidance
  6. D-06

    Remove engineering claims when their dated evidence is no longer current.

    Given up
    Permanent claims based on an old release.
    Wrong for you if
    Dated, removable evidence feels too cautious.
    Review the current trust evidence
Current evidence

Read the claims with dates on them

Capell.app and the public demo run on Capell. Check the source, follow the dated evidence, and treat an absent metric as an intentionally withdrawn claim. Paid priority support is not offered at launch while its tax treatment is reviewed; paid product terms continue to include standard support.

Find the capabilities that remove the next layer of CMS glue

Redirect health monitoring

Track redirect health as an operating concern without discovering dead paths from visitors.

See delivery

Multisite with deletion-impact preview

Manage several sites while previewing the effect of destructive site-level work.

Read the owner path

Localised media metadata

Keep alt text and related media context aligned with the language presented to visitors.

See content

Reviewed marketplace releases

Add optional capability through Composer packages whose release state remains visible.

Browse extensions

Theme system with ThemeDoctor

Keep presentation replaceable and run explicit checks against the installed theme contract.

Browse themes

Agent Bridge

Let external agents inspect approved capabilities without granting silent publishing authority.

See the agent boundary

Theme maintainability diagrams

Capell operations health checks covering public delivery and redirects.

Who gets the most value from this shape?

The same architecture pays back differently for delivery teams, product teams and individual developers.

Choose the path closest to the decision you need to make next.

Agencies

Standardise the operating path, not the client's design

Reuse Page, upgrade and handover conventions while each application keeps its own frontend.

Read the agency path

Product teams

Put publishing risk beside the product code

Give editors a clear place to work, and share the live demo with the developer who owns the application.

Read the editor path

Solo developers

Start with Foundation and keep the dependency visible

Install the MIT-licensed base, inspect the contracts, and add paid workflow only when the team needs it.

Install Foundation
A Capell request moving from a Laravel route through a Page and blueprint into application-owned Blade output.

Trace one Capell request inside Laravel

One request moves through Laravel routing, a Page with event history, a blueprint and the application's own presentation. The boundary stays inspectable without a second runtime round trip.

A real Capell readiness report showing versioned checks and their current status.

Why are upgrades a command, not a project?

capell:install, capell:upgrade and capell:doctor give teams one repeatable operating path. Agencies can apply the same checks across a fleet while each application keeps its own code, database and release decision.

The screenshot is a real readiness surface. It is evidence of the command shape, not a promise that every check will pass on every installation.

When is Capell the wrong choice?

Use these questions to disqualify Capell before a pilot costs the team time.

Use the full fit guide
Do you need a separate content API?

Choose a separate content platform when several unrelated applications must consume the same content through an API. Capell is coupled on purpose: it belongs inside the Laravel application.

There is no public content-delivery API, and that is a decision, not a gap. The application resolves a page, hydrates its content and renders it with its own stack, which is exactly wrong for a mobile app, a second website and a kiosk all reading one shared content store.

If your architecture is headless, a headless platform will serve you better, and this question should save you the pilot.

Can you buy Capell today?

Yes. Public checkout is open for paid Marketplace products. Foundation remains available under the MIT licence without a purchase.

Install Foundation from public Packagist releases, or review a paid package's published terms and pricing before buying it through the Marketplace.

If your plan needs a paid package in production this quarter, review its release status, compatibility and licence terms before adopting it.

Is Capell sensible for five client sites?

It can be when the sites share a delivery method and your team values repeatable upgrades, Page recovery and reviewed packages. Confirm the licence and package fit before standardising.

The agency case is where the shared model pays twice: page structures, workflows and packages proven on one client site carry to the next, and upgrades run as the same commands on every project without five bespoke procedures.

Standardising is also where a wrong fit multiplies by five, so run the disqualifying questions on this page against your actual client mix first, not against the site you happen to be building this month.

What about the bus factor?

Capell is founder-maintained, and its paid commercial programme is early. The Foundation source is MIT licensed, paid-package continuity terms are published, and the current operating limits are stated plainly.

Weigh what the licences actually guarantee, not what a roadmap promises. Foundation being MIT means the code your sites run cannot be taken away or re-licensed out from under you; the continuity terms state what happens to paid packages you have already installed if entitlement lapses.

Then weigh the honest residual: a small maintainer surface is a real concentration of knowledge, and no licence fixes that. If your organisation requires a vendor with a support bench today, that is a legitimate reason to choose differently.

Why not build the CMS directly with Filament?

Build directly with Filament when a few resources and custom pages are enough. Choose Capell when Pages, URLs, Page history, layouts, themes, publishing and package lifecycle should share one maintained contract.

The test worth applying is who maintains the contract. A hand-built Page resource is yours to evolve: every URL rule, revision behaviour and layout convention added later is code your team designs, tests and upgrades. With Capell those contracts arrive maintained, and your additions plug into them through packages.

The comparison page walks a concrete requirement list through both routes; take the list, not the conclusion.

Should we stay with the CMS we already have?

Staying put is a valid outcome. Keep the current CMS when it already fits the team, the migration cost exceeds the maintenance cost, or the paid commercial programme's early stage adds risk you do not need.

Migration cost is mostly not the content transfer; it is retraining editors, rebuilding integrations and rebuilding the operational confidence your team has in the current system's failure modes. Price those honestly before comparing feature lists.

The migration guides here start from the same premise: name every consumer of the old system before removing anything. If working through that exercise shows the current CMS still fits, you have lost an afternoon, not a quarter.

Questions

Questions worth answering before you adopt

Who maintains Capell?
Capell is founder-maintained. The Foundation source is MIT licensed, support windows for the current release line are published to specific dates, and continuity terms for paid packages are published rather than implied. Read the signed continuity boundary and how Capell is funded.
What happens to paid packages if Capell stops?
Installed paid packages keep running after an entitlement ends; protected downloads, updates and included support do not. A discontinued first-party package has its source released under the MIT licence, so continuity does not depend on protected download access.
Can an agency run several client sites on Capell?
Foundation is MIT licensed and carries no site limit. Paid terms are per customer organisation and cover 1 production application or domain plus 2 non-production environments, so an agency building several client sites needs an entitlement per client production application. The software itself is not limited to one site.
Is Capell too new to adopt?
Capell is young, and that is a real consideration. What reduces the risk is that Capell does not take ownership of your application: you keep a normal Laravel application, ordinary Composer packages, your own database and your own frontend, on an MIT-licensed foundation with dated support windows.
Loading section
Capell publishing controls arranged around a recoverable Page history.

Try to break a Page, then restore it

Follow the Foundation recovery track: open a Page, inspect its history, preview the difference and trace the restore path.

A specific test Inspect the recovery path without taking a rollback claim on trust.

Inspect the workflow, then decide whether it belongs in your Laravel app

The live demo is open; site planning is available through the assisted design-partner beta.

Agencies can use the demo as a shared evaluation path and review paid packages in the Marketplace. Foundation is £0 under the MIT licence; public checkout is open.

Loading footer