Instead of generating tokens in every form, move the logic into middleware. Cleaner, reusable, centralized.

Middleware isn’t just for auth. You can generate a unique token for each form load to prevent duplicates.

How do you handle double form submissions in your projects: JS, middleware, or both?

Duplicate entries are a common problem in forms. Generating a one-time token per form is a reliable solution

Accidental double submits can corrupt your database. Laravel middleware gives a clean way to prevent this.

what’s something you learned way too late in Laravel?

what’s the first thing you always check when real-time isn’t working?

do you test multi-user flows early or only when something breaks?

Most Laravel devs don’t get stuck on WebSockets… They get stuck on: “why is my channel failing to authenticate?” We walked through exactly that in today’s video.

We just dropped a full breakdown on real-time checkboxes in Laravel. Not just “here’s how it works” But the part people get stuck on: auth + whispering + why nothing connects at first

real-time is where “it works on my machine” starts falling apart

real-time exposes your patterns fast stuff that felt “simple” suddenly matters a lot more

Most devs use AI tools, but most also don’t fully trust them...

what changed in your code once you added real-time?

I think the weird part isn’t that Laravel makes real-time easy… it’s that we’re used to it being complicated

The next era isn’t prompt ops — it’s persistent autonomous agents running in the background.

what’s one thing beginners focus on too much… and one thing they don’t focus on enough?

WWDC 2026 is around the corner 👀 what are yall looking forward to this year

Laravel makes real-time feel so easy it almost feels wrong

what’s one thing AI actually improved in your workflow… and one thing it made worse?

what’s something in Laravel you wish someone would just explain better?

First time setting up real-time in Laravel felt… suspicious like you run one command and suddenly it’s working no way that’s it

The “it works on my machine” mindset kills workflows, not features.

I’d rather slow down the queue than lose control of the entire workflow.

Stop thinking in steps. You should be thinking in workflows.

Do you actually test if your system fails cleanly?

Good systems don’t just run correctly, they fail correctly.

If you can’t stop it cleanly…do you really control it?

Even if everything usually works… can your system handle when it doesn’t?

Broke this down fully today if you’ve run into these problems

Individual jobs: “just run this” Workflows: “this entire process needs to succeed”

Heres the problem: Some things are tasks and some things are workflows. But you’re treating them the same way

Seeing them run in order makes it obvious that this was never meant to be separate work

One finishes → next starts one finishes → next starts that’s when it stops feeling like “jobs”

Add a delay to each job… and you can literally watch the workflow happen step-by-step

Do you know difference between “working code” and “reliable code”?

The moment you need: • ordering • cancellation • shared outcome you’re not dealing with separate jobs anymore

If step 3 depends on step 2… you’ve already made your decision

The question isn’t: “should I use jobs?” it’s: “do these steps succeed independently?”

A lot of workflows look independent in code… but aren’t independent in reality

Remember, just because you can split something into jobs doesn’t mean they should be treated separately

Dispatching jobs separately feels clean but it hides the fact that your steps aren’t independent

You don’t notice bad job design early… You notice it when something goes wrong and nothing knows how to react

When designing UI data flows: Do you usually assume requests should • cancel previous requests • queue up • or run independently?

Everything works… until one job fails and the rest keep going anyway

A good reminder when upgrading frameworks: Behavior you relied on might not be a feature, it might have just been an implementation detail. We explored an example of that in the latest Inertia episode.

Should new requests cancel previous ones, or should they run independently?

One thing we revisited in yesterday’s episode: What happens when multiple partial reload requests fire at the same time?

I seriously hate when something fails halfway through and now your system is in a weird in-between state

Full episode + quiz on YouTube.