refresh page after updated model - Laravel
Stefan Bogdanescu
Founder & Senior Architect · 2026-06-29
# Refresh Page After Model Update in Laravel: Mastering Redirection
As developers working with Eloquent models in Laravel, one of the most common requirements is ensuring a smooth user experience after data modification. When a user updates a record, they expect to be redirected back to the same page, often showing the newly updated data. The goal here is to implement the classic POST/Redirect/GET (PRG) pattern.
The attempt you made using the `updated` hook in your model is a great starting point, as it targets the exact moment the database record changes. However, simply returning `back()` or redirecting inside the model event listener often fails because the redirection logic needs to be handled within the context of an HTTP request lifecycle managed by the Controller, rather than solely within the Eloquent model itself.
Let’s dive into why your initial approach might have failed and explore the correct, robust ways to achieve a seamless page refresh after a user update.
## Understanding Model Events vs. Request Flow
Eloquent model events (like `updated`, `created`, `saved`) are excellent for triggering side effects *within* the application logic. They fire when an Eloquent operation completes. While you can use them to initiate redirects, relying solely on them for front-end navigation can be brittle because it doesn't always align perfectly with how Laravel handles session and request state management across routes.
When a user submits a form:
1. The browser sends a `POST` request to the server.
2. The Controller receives the request.
3. The Controller handles validation and calls `$model->save()`.
4. If you redirect immediately after saving (using `return redirect()->back();`), Laravel correctly handles the HTTP response, ensuring the subsequent GET request loads the correct data.
The issue often arises when trying to force a navigation change deep within the model structure, which bypasses the standard routing mechanisms that handle session flashing and request loading.
## The Correct Approach: Controller-Driven Redirection
The most reliable pattern for handling form submissions and subsequent redirects is to manage this flow entirely within your Controller. This ensures that you are correctly utilizing Laravel’s built-in session management and route handling, which is fundamental to building scalable applications, as championed by the principles found in [laravelcompany.com](https://laravelcompany.com).
Here is how you should structure the update process:
**Example Scenario (Controller):**
```php
// app/Http/Controllers/PostController.php
use App\Models\Post;
use Illuminate\Http\Request;
class PostController extends Controller
{
public function update(Request $request, Post $post)
{
// 1. Validate the incoming data
$validatedData = $request->validate([
'title' => 'required|string|max:255',
'content' => 'required',
]);
// 2. Update the model
$post->update($validatedData);
// 3. Redirect back to the previous page with a success message
return redirect()->route('posts.show', $post->id)
->with('success', 'Post updated successfully!');
}
public function show(Post $post)
{
// Load the post data for display
return view('posts.show', compact('post'));
}
}
```
Notice that in this controller, after `$post->update()`, we explicitly redirect using `redirect()->route(...)`. This is cleaner because:
1. It clearly separates the business logic (updating the model) from the presentation logic (redirecting the user).
2. It guarantees that Laravel's request lifecycle correctly handles the session flash and subsequent GET request, ensuring you refresh the page with the correct, updated data.
## When to Use Model Events
While the Controller is best for handling redirects after writes, Eloquent events are still invaluable for triggering secondary actions. If you want to perform an action *after* a successful save—such as sending an email, logging an event, or updating related tables—the model observer is perfect:
```php
// app/Models/Post.php
use Illuminate\Support\Facades\Mail;
class Post extends Model
{
protected static function booted()
{
static::updated(function ($post) {
// This runs immediately after the database update is successful.
if ($post->is_published) {
// Example: Send a notification email
Mail::to('admin@example.com')->send(new PostPublished($post));
}
});
}
}
```
## Conclusion
To refresh the page correctly after an update in Laravel, shift your focus from trying to manage HTTP redirection within the model events to managing it within your Controller. By following the established POST/Redirect/GET pattern in your controller methods, you ensure that your application maintains robust state