Skip to main content
Capell home
Live demo
Filament already solves the admin surface. Adopt Capell when public pages are making your team rebuild URLs, previews, layouts and publishing conventions resource by resource.
CMS capture · Content index Every page and its structure stay visible in the admin. The populated Pages index keeps page hierarchy, publish status, update time, page type, and PageSpeed state visible beneath its SEO overview.
CMS capture: page structure Page families are defined once. A real Filament screen showing the registered page structures editors use instead of rebuilding content rules inside each page.

Real Capell product screens

Actual Capell CMS Pages index showing its SEO Overview and columns for Page, Publish status, Updated at, Page type, and PageSpeed.

Filament 5 workspace Shared page and URL model Public Packagist foundation

Give publishing a familiar home

Let editors manage pages in Filament without making your team build every CMS workflow from scratch.

Filament is a strong foundation for Laravel administration. Capell adds a publishing model around public pages: repeatable definitions, preview, Page history and recovery. It is useful when those page concerns recur alongside the business resources your team already maintains.

Capell page type definitions
Page types add reusable publishing definitions alongside the custom resources already in your Filament admin.

Filament is an excellent admin foundation. A few editable records, internal tools or stable settings do not need a full CMS. Custom resources keep that work direct and easy to understand.

The maintenance problem begins when those records become public pages. URLs need history, editors need previews, layouts repeat, translations have to line up, and the application needs a dependable route from stored content to public HTML.

Custom resources remain enough when

  • The work is mainly internal CRUD or a small set of settings.
  • Public routing and presentation are simple and stable.
  • Your team is comfortable owning each CMS convention locally.

Adopt a shared model when

Several page families need the same URL, preview, layout and publishing behaviour. Capell keeps the Filament workspace while giving those concerns one implementation. Developers can then spend their custom code on the parts of the site that are actually unusual.

What to inspect

Compare one existing resource with the demo workflow. Count the route, form, preview, history, metadata and rendering code around it. Capell is worth it only if the shared model removes more maintenance than it introduces.

Separate editing from development

Give editors clear changes they can make without technical help.

An editor needs to find the page, understand its fields and see what the change will do. A developer defines the page family, presentation and permitted choices. Keeping that division clear avoids asking editors to manage application structure just to correct an offer.

Use the same Filament environment where it fits the project, but keep application-specific resources and business rules in their own code. Shared administration does not mean every model should become a CMS page.

Evaluate the missing work

Compare Capell with the publishing features your custom resources would need.

A few stable resources can be simpler to maintain directly. Repeated public pages need more surrounding work: URLs, preview, history, shared presentation and an understandable correction path. Inspect that whole workload before choosing.

Trial Page history and recovery, then decide whether Publishing Studio's approval process is needed. Check actual package scope rather than assuming every admin screenshot represents Foundation alone.

Ownership map

Move the repeated work out of individual resources

A page can look like any other Filament record to an editor while the application applies consistent CMS behaviour around it. Developers stop inventing a new route, preview and metadata convention for each resource.

Keep custom resources for internal records and stable settings. Reach for Capell when those records become public page families that should change together and produce responses your tests can inspect.

Pages behave like pages

Editors manage content, URLs, translations and metadata without each page family learning different rules.

View system map

Layouts use tested components

LayoutBuilder lets editors assemble a page from components the team has designed, shipped and can update later.

See LayoutBuilder

Add a feature for a real job

SEO, search and publishing workflow can be installed as packages after the team reviews their migrations and public impact.

Browse packages

Test what visitors receive

Capell Frontend connects approved content to project themes and Blade components without exposing admin state in the response.

See the rendering path
Comparison

Compare Capell with a custom Filament admin

Best fit

Capell
Large Laravel websites that need CMS structure and public output.
Custom Filament admin
Internal tools or bespoke admin screens where CRUD covers the whole need.
Headless CMS
Teams that want content APIs outside the Laravel app.
WordPress
Sites where the plugin and theme ecosystem matters most.
Hosted builder
Hosted visual site builds where the frontend can be owned by the builder.

Admin surface

Capell
Filament admin plus Capell page, layout, package, and publishing concepts.
Custom Filament admin
Raw Filament resources the team designs and maintains.
Headless CMS
A separate CMS admin away from Laravel.
WordPress
A familiar admin with plugin-shaped structure.
Hosted builder
A hosted designer and editor.

CMS model

Capell
Pages, URLs, translations, layouts, navigation, themes, media, metadata, and extension points.
Custom Filament admin
Whatever tables, resources, and conventions the team creates.
Headless CMS
Remote content models queried over APIs.
WordPress
Posts, pages, custom fields, and plugins.
Hosted builder
Hosted pages and collections.

Public rendering

Capell
Blade in your Laravel app, Livewire, cache, hooks, APIs, and route-backed output.
Custom Filament admin
Whatever render path the team builds around admin data.
Headless CMS
A consuming frontend renders remote content.
WordPress
Theme and plugin output.
Hosted builder
Hosted output controlled by the builder.

Growth path

Capell
Composer packages, manifests, install impact, marketplace trust, and optional extensions.
Custom Filament admin
Copied resources, local packages, or one-off service classes.
Headless CMS
Platform plugins and integrations.
WordPress
A large but uneven plugin ecosystem.
Hosted builder
Closed marketplace apps and scripts.
Loading section

Next step

Compare the workflow with your current resources

Use the demo to judge whether one page model would remove enough maintenance from your Filament admin.

Inspect how an editor finds a page, changes it, previews it and follows it to public output. Keep your custom build if the extra model does not justify its place. Read why Capell keeps a shared Page model.

Filament CMS: Actual Capell Page editor showing the Blog page URL, title, Hero and Content editors, Extra Content, SEO Settings, publishing state, parent, blueprint, and layout controls.

Role scenarios

What to inspect in a Filament CMS

Checks for deciding when shared CMS structure earns its place beyond a custom admin.

Role-based checks drawn from product capabilities and fit boundaries.

Actual Capell Types index for the developer workflow described.

Compare repeated content in Filament and Capell

Model the same repeated content and URL rules first as copied Filament resources, then as a shared page type. Compare the changes required when a field or publishing transition is added across every instance.

Read more

Capell gives that repeated content one shared model plus a real editorial state machine, so a page moves draft to approved to published through enforced transitions and the aggregate throws when someone tries to jump it straight to archived. The client keeps Filament while dropping the copy-paste resource work.

If their admin is genuinely one-off with no repeating content, plain Filament resources are lighter and teams should stay there. The shared model pays off with repetition, not novelty.

Run this yourself in the demo

Laravel Technical Lead

Evaluator scenario for a Laravel technical lead

Loading footer