In Laravel, when would you use Route::model(), Route::bind() or an overridden resolveRouteBinding() instead of plain implicit route model binding?

## Where implicit binding stops Implicit binding is driven by the action's signature: a model type-hint plus a variable named after the segment, resolved with `where(routeKey, value)->first()`. That covers most routes. It is not enough when: - the action does not type-hint the model (an untyped closure parameter, or legacy code); - the lookup needs extra conditions — only non-archived tasks, a case-insensitive code, a tenant filter; - the value to inject is not an Eloquent model at all; - the same custom lookup must apply everywhere the model is bound. Laravel offers three explicit tools for these cases. ## `Route::model()`: bind a segment name to a class ```php public function boot(): void { Route::model('task', Task::class); } ``` From then on every `{task}` segment in every route resolves to a `Task` through the model's `resolveRouteBinding()`, whether or not the action type-hints it. A missing row throws `ModelNotFoundException` (a 404) unless you pass a third argument — a closure that receives the raw value and returns a fallback instead. ## `Route::bind()`: run your own resolver ```php Route::bind('task', function (string $value) { return Task::where('code', strtoupper($value)) ->whereNull('archived_at') ->firstOrFail(); }); ``` - The closure receives the segment's raw value (and the route) and returns whatever should be injected. - To get a 404 it must throw; `firstOrFail()` throws `ModelNotFoundException` for you. - Hyphens in the key are normalised to underscores. - Because the binder is keyed by segment name, it applies to every route using `{task}`. Name segments deliberately, or one binder changes routes you did not intend. ## Order: explicit before implicit The binding middleware runs explicit binders first, then implicit binding. Implicit binding skips any parameter that already holds a model, so an explicit binder wins for its segment and no second query runs. `missing()` on the route catches a `ModelNotFoundException` from either stage. ## Overriding `resolveRouteBinding()` on the model When the custom rule belongs to the model rather than to a URL, override the method Laravel calls for every binding of the class: ```php public function resolveRouteBinding($value, $field = null) { return $this->where($field ?? $this->getRouteKeyName(), $value) ->whereNull('archived_at') ->first(); } ``` - Top-level implicit binding and `Route::model()` both call it, so the rule applies to every unscoped lookup of the model. - Returning `null` still produces the standard 404. - **Honour `$field`**: an override that hard-codes a column ignores `{task:slug}` on routes that ask for it. - For query-only tweaks, overriding `resolveRouteBindingQuery($query, $value, $field)` is narrower and keeps the rest of the pipeline intact. - Scoped child lookups do not call the child's `resolveRouteBinding()`; they go through the parent's `resolveChildRouteBinding()`, which builds the query with the child's `resolveRouteBindingQuery()`. A rule placed in `resolveRouteBindingQuery()` therefore covers both paths. ## A worked example: case-insensitive task codes A project tracker shows tasks as `/tasks/PRJ-104`, but users type `prj-104` into the address bar. Implicit binding compares the string as-is, so the lowercase URL 404s on a case-sensitive column. A `Route::bind('task', ...)` closure that upper-cases the value before querying fixes every route using `{task}` at once. Beware one interaction: on a route with scoped bindings, the explicit binder runs first and implicit binding then skips the parameter, so the task is no longer scoped to its project. If the rule must coexist with scoping, put it in the model: override `resolveRouteBindingQuery()` on `Task`, which Laravel uses for top-level lookups and, through the parent's relationship, for scoped child lookups too. ## Choosing | Need | Tool | |---|---| | Bind a segment to a model without relying on type-hints | `Route::model()` | | One-off custom lookup or a non-model value for a segment name | `Route::bind()` | | A rule that must hold for every binding of the model | Override `resolveRouteBinding()` or `resolveRouteBindingQuery()` | | Just a different column | `{task:slug}` or a model route key — no explicit binding needed | The docs place explicit binders at the start of `AppServiceProvider::boot()`. Keeping them together there also makes the global, name-wide effect of each binder easy to audit.