A workspace built for careful editing
“Capell Admin puts page changes, media, translations and publishing in one place, with checks that stop a wrong click from breaking the live site. Routine edits stop queueing behind a developer request.”
Page building without surrendering the frontend
Page builders become expensive when every page turns into a unique design surface. Capell uses LayoutBuilder widgets, reusable sections, and assignable assets so editors can build useful pages without inventing markup.
The public frontend still belongs to the Laravel application. Blade, Livewire, Inertia, Vue.js, cached HTML, and custom stacks can render the page data your team approves.
Signed-off widgets Reusable sections Frontend-owned output
Page building in Capell is not a blank canvas. It is approved composition. Editors can assemble useful pages, but the building blocks are designed, named, and rendered by the development team.
That tradeoff is deliberate. A freeform builder feels fast until every landing page has its own spacing, markup, accessibility problems, and performance quirks. Capell gives editors room to work without handing over the frontend.
How to think about it
- Use page types when a set of pages should share the same structure.
- Use LayoutBuilder widgets when editors need to arrange sections.
- Use custom Laravel views when a page really is a bespoke product surface.
- Keep the public HTML owned by the application, not by editor state.
The best setup is usually boring: a small library of well-made widgets, clear page types, useful previews, and enough flexibility for campaigns before every page becomes its own project.
The page building contract
Capell page building is strongest when the team separates content choices from presentation ownership. The editor chooses from useful blocks; the application renders those blocks deliberately.
Page Building
Give editors approved page composition in Laravel with LayoutBuilder widgets, reusable sections, previews, and frontend-owned rendering.
Start with the practical question: what does the visitor or editor need to do next? Capell keeps that answer tied to the Laravel app, with shared structures for repeated pages and enough room for custom work when the project genuinely needs it.
Guarded composition for real Laravel teams
Senior Laravel teams usually do not object to editors moving sections around. They object to inheriting a visual canvas where every page can become its own implementation. Capell keeps composition useful by making the editable choices explicit: known containers, widgets you approve, assigned content, page-level metadata, and a frontend renderer the application team can test.
Before giving editors a new page-building surface, decide what the team is prepared to support:
- which page families need composition instead of a fixed page type;
- which components can be reused without weakening accessibility or performance;
- which media, forms, search, and package-backed blocks are safe to expose; and
- which preview, review, and cache behavior must run before public release.
That framing turns page building into a product workflow instead of a shortcut around engineering. Editors get speed, but the public site still goes through the same design system, review habits, and deployment discipline as the rest of the Laravel app.
Questions
Page building questions
Capell page building is intentionally guarded: enough flexibility for publishing, enough structure for future redesigns.
Is LayoutBuilder a freeform canvas?
No. It is a composition layer for widgets you approve and containers. That keeps brand, accessibility, and frontend performance in code.
Can developers make custom sections?
Yes. Developers can define widgets, views, assets, schemas, and package-backed blocks when a page needs a richer editing surface.
What happens during a redesign?
Shared widgets and page types can be updated in one place instead of editing dozens of individual pages by hand.
Next step
Build pages from parts you can still maintain
After composition, the next decision is publishing workflow: who can preview, approve, schedule, roll back, and refresh the public output.
Approved composition Editors choose sections. Developers own the rendered HTML, CSS, assets, and tests.
Reviews
Why editors like Capell Admin
Short notes on editing, previewing and publishing with more control.
A Filament workspace you can extend
“For a technical lead, Capell Admin is a structured Filament surface that already wires pages, media, translations and publishing together, so the team extends a coherent admin instead of assembling resources, policies and previews from scratch.”
An admin clients can run without you
“For an agency, Capell Admin is what lets a client take over day-to-day content after handover: one guarded workspace for pages, media and publishing. Routine changes stop coming back as billable support tickets.”
What makes page building safe to maintain
Capell page building is not meant to be an unrestricted canvas. It gives editors enough composition to publish varied pages, while developers keep the reusable widgets, containers, design system, accessibility, performance, and tests in code.
| Area | Capell shape | Developer check | Team outcome |
|---|---|---|---|
| Approved parts | LayoutBuilder pages use known widgets, sections, containers, and assets. | Define the page parts the team is prepared to support long term. | Editors can move quickly without inventing a new frontend per page. |
| Reusable rendering | Each widget renderer can serve many pages. | Keep markup, loading behavior, and responsive rules in shared components. | Redesigns improve a page family instead of a single page. |
| Preview path | Composed pages need validation, preview, review, publish, and cache refresh. | Test the path from draft composition to public output. | Publishing feels flexible without becoming risky. |
| Escape hatch | Custom Laravel pages stay available where the content model is not the right fit. | Choose custom code deliberately for product-heavy or unusual flows. | The CMS supports exceptions without making every page exceptional. |
Capell learning journey
Step 2 of 4: Platform
Capell is a Laravel CMS split into four parts: Core, Admin (Filament), Frontend, and Packages. See how they fit your project.
Keep moving through Content
Content, pages, media, forms, search, and languages.