Filament v5.8 landed on October 27 with a headline feature that addresses a long-standing pain point: deferred schema loading. If you've built Filament forms with collapsed sections, tabbed interfaces, wizards, or repeaters, you know the problem — every field in every hidden pane gets rendered on the initial request, even if the user never expands it. On complex resource pages, that adds up.
v5.8 changes this with a generic deferred loading system. Child schemas (collapsed sections, inactive tabs, later wizard steps, collapsed repeater items, Builder blocks) now render a lightweight placeholder first. The actual fields load via a separate Livewire request only when they scroll into the viewport or the user interacts with them.
How it works
The implementation uses an Intersection Observer on the client side. When a deferred region becomes visible — whether by expanding a section, switching a tab, advancing a wizard step, or scrolling a collapsed repeater item into view — Livewire fires a loadItem request that renders just that schema fragment. State persists in the parent component's data array across collapse/expand cycles, so expanding a section twice doesn't re-fetch or lose input.
Validation still runs against unloaded fields. If a required field sits inside a collapsed section and the user submits, Filament automatically expands and loads that section so the validation error surfaces correctly.
The API
There are two entry points depending on which component you're using.
Sections, Tabs, Wizards, Repeaters — Schema::make()->deferLoading()
For the classic layout components, wrap your field array in a Schema object and chain deferLoading():
use Filament\Schemas\Schema;
use Filament\Forms\Components\Section;
use Filament\Forms\Components\TextInput;
use Filament\Forms\Components\Tabs;
use Filament\Forms\Components\Tabs\Tab;
use Filament\Forms\Components\Wizard;
use Filament\Forms\Components\Wizard\Step;
use Filament\Forms\Components\Repeater;
Section::make('Customer details')
->schema(
Schema::make()
->components([
TextInput::make('name')->required(),
TextInput::make('email')->email()->required(),
TextInput::make('phone'),
])
->deferLoading(),
)
->collapsed()
->key('customer-details'); // required for deferred sections
Tabs::make('Account')
->schema(
Schema::make()
->components([
Tab::make('Profile')
->schema([
TextInput::make('name'),
TextInput::make('bio'),
])
->deferLoading(),
Tab::make('Settings')
->schema([
TextInput::make('timezone'),
TextInput::make('locale'),
])
->deferLoading(),
])
->deferLoading(),
)
->key('account-tabs');
Wizard::make()
->schema(
Schema::make()
->components([
Step::make('Basics')
->schema([
TextInput::make('title')->required(),
])
->deferLoading(),
Step::make('Details')
->schema([
TextInput::make('description'),
])
->deferLoading(),
])
->deferLoading(),
)
->key('create-wizard');
Repeater::make('team_members')
->schema(
Schema::make()
->components([
TextInput::make('name')->required(),
TextInput::make('role'),
TextInput::make('email')->email(),
])
->deferLoading(),
)
->collapsed()
->key('team-repeater');
Important: every component that uses deferred loading needs a key() on the parent (the Section, Tabs, Wizard, or Repeater). This key identifies the region for the Livewire partial render.
Builder blocks — ->lazy()
The Builder component uses a slightly different API. Call lazy() on the Builder itself, and optionally opt individual blocks out with lazy(false):
use Filament\Forms\Components\Builder;
use Filament\Forms\Components\Builder\Block;
Builder::make('page_content')
->blocks([
Block::make('hero')
->schema([
TextInput::make('headline'),
TextInput::make('subheadline'),
]),
Block::make('features')
->schema([
TextInput::make('title'),
TextInput::make('description'),
])
->lazy(false), // this block always renders eagerly
Block::make('testimonial')
->schema([
TextInput::make('quote'),
TextInput::make('author'),
]),
])
->lazy()
->lazyUnloadOnCollapse(true); // optional: unload when collapsed again
The lazyUnloadOnCollapse(true) option (also available on the Schema approach via deferLoading(unloadOnCollapse: true)) discards the loaded state when the user collapses the region again. The next expansion triggers a fresh load. Without it, the rendered fields stay in memory and reappear instantly.
When it helps most
Deferred loading shines on resource pages with:
- Collapsed sections that contain heavy fields (rich editors, file uploads, relationship managers)
- Tabbed interfaces where users typically only visit one or two tabs
- Multi-step wizards where later steps have complex validation or conditional fields
- Repeaters with many items where most start collapsed
- Builder-based page builders with dozens of possible block types
On a typical admin resource with 30+ fields split across tabs and collapsed sections, initial render time can drop by 40–60% because the browser only hydrates what's visible.
Gotchas and limitations
| Gotcha | Details |
|---|---|
key() is mandatory |
Without a unique key on the parent component, Livewire can't target the partial render. |
| Validation expands automatically | A missing required field in a deferred region forces that region to load on submit. This is correct behavior, but test your forms to ensure the UX makes sense. |
| State persists by default | Expanded content stays in the Livewire data array. If you have computed fields or expensive accessors that shouldn't re-run, they won't — but if you need fresh data on re-expand, use unloadOnCollapse: true. |
| No SSR for deferred content | The initial HTML only contains placeholders. If you rely on search engines crawling form content, this won't help (though admin panels rarely need that). |
| Package compatibility | The schema() method signature in HasChildComponents now accepts Filament\Schemas\Schema. Packages that extend Filament's schema system (like awcodes/filament-flex-fields) may need updates. |
Other v5.8 improvements worth knowing
Deferred loading is the headline, but v5.8 ships several other quality-of-life upgrades:
- Session-persisted table grouping —
persistGroupInSession()remembers the user's grouping choice across page loads. - Default grouping direction —
defaultGroup('status', direction: 'desc')sets the initial sort order for grouped tables. - Trait-named lifecycle hooks —
afterSaveHandlesDrafts()on a trait now runs after the page'safterSave(), enabling cleaner cross-cutting concerns. - Stat placeholders — Stats can now show placeholder content while loading async values.
- Reusable
MultiFactorChallenge— A dedicated class for MFA challenges, decoupled from specific panels. - RichEditor height controls —
minHeight()andmaxHeight()on the editor component. - Custom export downloaders — Implement your own download logic for table exports (useful on Vapor/serverless).
Upgrading
Filament v5.8 requires PHP 8.2+ and Laravel 11+. The upgrade is generally smooth — run composer require filament/filament:"^5.8" and check the upgrade guide for any breaking changes specific to your setup. The schema method signature change is the main one to watch if you have custom form components or use packages that extend the schema system.
Takeaway
Deferred schema loading is one of those features that feels obvious in hindsight: don't render what the user can't see. For Filament teams building data-dense admin panels, it's a meaningful performance win with minimal code changes. Add ->deferLoading() to your collapsed sections and tabs, set a key(), and you're done.
If you're on Filament v5.x, upgrading to v5.8 is low-risk and high-reward. The feature is opt-in, backwards-compatible, and solves a real problem without introducing new abstractions to learn.