Skip to main content
Capell home
Live demo

A publishing CMS inside your Laravel app

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.

Capell supports growing sites with page history, recovery and a clear separation between editing and public content.

Make change less expensive

Keep pages consistent and recoverable after the website has left the launch phase.

The reason to choose Capell is not that another CMS cannot publish a page. It is that your Laravel team repeatedly needs to improve pages, give editors useful control and correct mistakes without rebuilding the surrounding workflow. The evidence below lets you examine that argument instead of relying on a promise.

Capell Page history and recovery screen
Saved revisions make a mistaken page edit a recovery task rather than a manual rebuild.

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.

Think beyond launch day

Evaluate the repeated requests that usually make a website expensive.

A new service, a campaign refresh and a redesign should not each create another copied template. Shared page definitions and layouts make the repeated part maintainable while page-specific content stays independent. That gives developers a clearer place to make improvements and editors a clearer place to work.

The benefit depends on your site actually repeating those patterns. Keep bespoke development for genuinely different experiences, and compare alternatives when the project is small or the team prefers another operating model.

Ask for evidence

Inspect recovery, package scope and public behaviour before choosing.

Foundation Page history makes editorial change inspectable and recoverable. More formal review and publication arrive through Publishing Studio. Product captures and dated engineering results provide starting points for evaluation, not a guarantee about every project.

Use the demo and public source to inspect the workflow relevant to you. Follow current licence and package information, and test the difficult requirement in a pilot. A clear limitation is more useful than a vague assurance when making a long-term decision.

Keep pages recoverable after 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.
Decision ledger

Why Capell is built this way

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 general content API for several applications 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
Why Capell: Actual Capell CMS page types screen showing registered content structures and their available editor actions.

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.

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.

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.

Why Capell: Actual Capell Page History showing four revisions and a validated roll-forward preview that restores a selected version without deleting history.

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.

Why Capell: Actual Capell Publishing Studio workspace screen showing review states, scheduled releases, draft ownership, and package workflow controls.

Inspect Page History in the demo

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.

Find packages for your next requirement

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 Capell is for

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

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.

Capell Foundation has no public content-delivery API, and the optional API package (beta, free) only returns read-only JSON for published pages. 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

Try the live demo

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