No Compromises

Have you ever handed off a feature request with barely any detail and expected the developer to just figure it out?

In the latest episode of the No Compromises podcast, we discuss why writing clear requirements is one of the most valuable things a business can do before development starts.

We make the case that even imperfect requirements beat none at all because they determine where the discovery happens, closer to the finish line rather than somewhere in the middle of the country.

We also cover why letting AI write your requirements for you is a trap, and how AI can help you review and cross-check requirements instead. And why the more detail you put in upfront, the less money you spend on surprises later.

Subscribe to the Mastering Laravel newsletter for practical insights that help you communicate better with your development team.

When someone says your app is slow and you need caching, do you actually know which layer of caching they are talking about?

In the latest episode of the No Compromises podcast, we discuss the many different forms caching takes in a Laravel application and why reaching for the cache facade is not always the answer.

We walk through caching from the outside in, starting with edge caching via Cloudflare, moving into Laravel's cache facade for third-party API calls, and all the way down to memoization with the Once helper for expensive in-request calculations.

We also make the case that storing data in a database table can be a perfectly valid caching strategy, and that the right question to ask is not whether to cache but what kind of caching actually fits the problem.

Get practical Laravel tips like these delivered to your inbox every day by subscribing to our newsletter.

Have you ever fixed a failing test by adding a variable to phpunit.xml and moved on, not thinking twice about whether that was actually the right call?

In the latest episode of the No Compromises podcast, we discuss a real pull request disagreement about where environment variables belong and why it actually matters.

We draw an important distinction between credentials and workflow configuration in your env file, and why that difference should determine exactly what goes into phpunit.xml and what stays out.

We also get into why zeroing out API keys and hostnames in your test environment is not optional, and how a small oversight in one PR can quietly expose your tests to real third-party services.

Have you ever let an AI agent run commands on your production server because you were stuck, telling yourself it would be fine?

In the latest episode of the No Compromises podcast, we discuss why giving AI agents access to your production environment is as reckless as the bad old days of FTPing code straight to your server.

We make the case that AI agents are non-deterministic and carry no responsibility, which makes them far more dangerous than a developer making a manual mistake on a live server.

We also cover why you should never blindly run complex chained commands that an agent suggests, how to verify what your agent is actually doing, and why a little friction in your workflow is worth the safety it buys you.

Stop letting non-deterministic tools make deterministic mistakes in your codebase. Get a code review.

Subscribe to our newsletter and get practical Laravel tips delivered to your inbox every day.

Have you ever been stuck on a problem and instinctively reached out to a real person instead of an AI, and found that was exactly the right call?

In the latest episode of the No Compromises podcast, we discuss why human collaboration still matters in a world where AI seems to have all the answers.

Aaron shares a late-night hardware crisis that a blog post from a real human solved, something AI never surfaced, and connects it to a bigger point about the value of having a trusted person to work through problems with in real time.

We also get into why video calls beat text, why knowledge sharing still matters even when AI seems to know everything, and why pushing back on a partner often leads to better code than just agreeing.

When you install a package, you probably skip the source code. But what about the AI skills and CLAUDE.md files you are feeding directly into your agent?

In the latest episode of the No Compromises podcast, we discuss whether developers are reading the AI skills they install and why it actually matters.

We make the case that unread skills are riskier than unread packages because they quietly shape how your agent thinks and can introduce security vulnerabilities or opinions you would never have agreed to if you had just taken 10 minutes to read them.

We also look at the flip side, where reading those skills can make you a better developer, expose you to approaches you did not know existed, and help you guide your agents more intentionally across every project.

Have you ever added a method to an enum and then wondered if you just turned it into something it was never meant to be?

In the latest episode of the No Compromises podcast, we discuss where to draw the line when adding methods and logic to PHP enums.

We trace the evolution from magic strings to constants to interfaces, and explain why enums were the missing piece PHP needed all along.

We also cover when label methods and data structure helpers belong on an enum, why Eloquent queries cross a line, and how to avoid turning a simple enum into a bloated helper class.

Have you ever opened a file to make a quick change, only to find dozens of lines of commented-out code making it nearly impossible to understand what's actually running?

In the latest episode of the No Compromises podcast, we discuss why keeping dead code around is slowing your whole team down.

We make the case that commented-out or unused code creates real confusion when searching a codebase, whether you are a new developer, a consultant, or even an AI agent trying to understand what is actually in use.

We also cover why Git is all the safety net you need, how Git bisect can recover deleted code you thought you might need someday, and why the fear of deleting code is almost always unfounded.

When a tool hands you a working solution, how much do you really need to understand about why it works?

In the latest episode of the No Compromises podcast, we discuss whether developers still care about understanding the code they ship, or whether that expectation is becoming a relic of the past.

We explore why knowing the "why" behind a solution isn't just about curiosity. It's about having enough domain knowledge to ask better questions, push back on bad answers, and ultimately produce better work.

We also walk through a real code review example involving a tricky Eloquent query, talk through the pressures that pull developers away from digging deeper, and consider what separates a line cook from a chef in how we approach our craft.

Ever feel like a project requirement says "we need multi-tenancy," and you're not even sure what that means in your specific context?

In the latest episode of the No Compromises podcast, we discuss how to evaluate multi-tenancy needs before committing to an architectural approach.

We break down what multi-tenancy actually means, from separate databases to custom domains and per-tenant configuration, and why the real question isn't which package to use, but whether you need one at all.

We also explore when hand-rolling a simple solution beats adopting a full package, what legal and compliance requirements can force your hand, and why this is one of those decisions that's genuinely hard to undo later.

00:00 Defining what multi-tenancy actually means
02:11 Different ways to structure multi-tenant systems
03:44 When separate databases are truly necessary
04:57 Questions to ask before choosing an approach
08:25 Package vs. rolling your own trade-offs
11:30 Silly bit

If you want guidance on decisions like these, check out our code review service to get expert eyes on your architecture.

Ever installed a Laravel package locally and immediately accessed it, only to wonder later whether your access controls are actually working in production?

In the latest episode of the No Compromises podcast, we discuss why tools like Telescope and Horizon behave differently in local environments versus production, and why that inconsistency is a problem worth solving.

We make the case that developer convenience should never come at the cost of security confidence. If your gate logic cannot be exercised locally, you cannot truly trust it is protecting your production environment.

We also dig into how Aaron worked around the issue by overriding the package's service provider logic, and why Laravel has since made this easier to handle cleanly.

Our courses took the production hits so your app doesn't have to.

Have you ever looked at a colleague's code and thought, "This is clearly wrong," only to find out it was actually a well-reasoned workaround for a tricky bug?

In the latest episode of the No Compromises podcast, we discuss what happened when Aaron reviewed Joel's code and couldn't make sense of a pattern spread across multiple Livewire components.

The code wasn't bad, it was solving a real UX flicker bug in an older version of Mary UI. But without context, it looked like a mistake and nearly got rejected. The fix wasn't just refactoring; it was giving the workaround a proper home: a trait with a descriptive name, clear method names, and thorough documentation explaining the bug, the reason for the pattern, and when it can eventually be removed.

We also talk about why "the explanation is in the PR note" isn't good enough, how AI coding agents can unknowingly propagate patterns they don't understand, and why strange code deserves to look strange, on purpose.

Explore Mastering Laravel resources to deepen your understanding of patterns like these.

00:00 The confusing code review that started this
01:15 Flagging the unclear pattern across components
03:54 The Mary UI toast flicker bug explained
05:45 Naming, documentation, and protecting the whole team
09:30 Silly bit

Do you ever finish writing a test and wonder if it is actually proving anything about your code or just confirming that Laravel works?

In the latest episode of the No Compromises podcast, we discuss how to tell the difference between tests that validate your logic and tests that merely exercise the framework.

We share a practical gut check: if you cannot make a test fail by changing something in your own application code, it probably should not be in your test suite. We also look at this idea from the other direction, asking whether the code being tested is something we actually wrote.

We also dig into why testing validation rules is worth the effort even when they feel boilerplate, how feature versus unit test style shapes these decisions, and why the real goal is simply getting to a place where your tests help you ask the right questions.

Join the Mastering Laravel community at https://masteringlaravel.io/community

00:00 Are we testing code or framework
02:00 Joel metric for framework-only tests
05:15 Bottom-up testing perspective by test type
07:36 Why validation rules still deserve tests
10:40 Silly bit

Does everyone need to have an AI hot take right now, or is there value in waiting until you actually know what you're talking about?

In the latest episode of the No Compromises podcast, we discuss why it took us 147 episodes to finally tackle the topic of AI.

We dig into the tension between wanting to speak with authority and feeling pressure to share before you're ready. Aaron makes the case for building deep knowledge first, while acknowledging that people at every stage of the learning curve play an important role in moving the community forward.

We also talk about how fast the AI landscape is shifting, why zooming out matters more than memorizing details, and why being a slower mover isn't something to apologize for.

When your project has the same thing done three different ways, how do you bring everything up to date with a consistent approach?

In the latest episode of the No Compromises podcast, we discuss different strategies for tackling upgrades when parts of your codebase are multiple versions behind.

We walk through two main approaches and weigh the tradeoffs for both the developer doing the work and the person reviewing it.

Ever feel the urge to write out calculations in your code to make them "self-documenting"?

In the latest episode of the No Compromises podcast, we discuss why inline math in configuration values is a habit worth breaking.

Aaron argues that if a value never changes, there's no reason to calculate it every time. A well-placed comment can explain how you got the number without the unnecessary overhead.

We also cover how comments can clarify units like seconds versus milliseconds, why this thinking applies beyond config files, and how questioning small habits can improve your code overall.

Found a cool package on Laravel News? But how do you know if it's actually worth installing?

In the latest episode of the No Compromises podcast, we discuss what we look for when evaluating third-party packages before bringing them into a project.

Aaron makes the case that what he finds in the tests folder is essentially a deal-breaker: no tests means no trust, but leaving default example tests behind is somehow even worse. Tests reveal whether the maintainer thought through edge cases and serve as living documentation when the README falls short.

We also cover the other signals we weigh: GitHub stars, download counts, issue responsiveness, and how quickly maintainers keep up with new Laravel versions.

Have you ever built a strong case for something, only to realize later you were solving the wrong problem?

In the latest episode of the No Compromises podcast, we discuss Aaron's surprising reversal on down migrations, a topic we've publicly discussed on this podcast.

We walk through the original arguments for writing down migrations and deconstruct each one.

Ever catch yourself second-guessing decisions you were confident about just months ago? Does that mean you're getting worse at your job?

In the latest episode of the No Compromises podcast, we explore why senior developers often feel "wrong" more frequently than they did earlier in their careers.

Aaron makes the case that this isn't a sign of declining skill—it's evidence of a richer mental model that reveals nuance where things once seemed black and white.

We discuss how feedback sources shift with experience, why changing your mind signals growth rather than failure, and how to reframe architectural decisions as a spectrum rather than binary choices.

Ever feel like you're wasting your time tweaking a section of code to get it just right? We have tools for that, don't we?
 
In the latest episode of the No Compromises podcast, we discuss when to trust auto-formatters and when to nudge code by hand.

Aaron makes the case that a few mindful minutes of “prettying up” can unblock harder thinking, without surrendering judgment to tools.

We set limits on this approach, share a tiered break strategy, and make it clear why you still own what the formatter changes.

It's easy to overcomplicate data modeling, especially when enums, relationships, and future requirements are in play. 
 
In the latest episode of the No Compromises podcast, Joel brings Aaron a real-world technical dilemma: how to model a relationship between two models when types are stored as enums, not models. 
 
We discuss the pros and cons of pivot tables versus JSON columns, the importance of context before jumping to solutions, and how developer instincts can sometimes get in the way of clarity.

It's easy to get so laser-focused on programming and tech, that you close yourself off to other avenues of learning.

In the latest episode of the No Compromises podcast, Aaron argues that non-tech reading can sharpen your engineering thinking.

We discuss balancing breadth without diluting focus, and how to turn casual reading into active learning with quick capture habits.

Multiple times we have encountered the messy reality of rebuilding a decade-old system: stale specs, missing specs, and stakeholders who want "the same… but better."

In the latest episode of the No Compromises podcast, we share a lightweight framework for agreeing on an MVP, tagging "post-MVP" ideas, and negotiating trade-offs while still making progress.

We walk through practical tactics for parallelizing work and learning as you go.

We join a fair number of projects, and we often help teams bring their project up to our standard. This means bringing a lot of the same small pieces from project to project.

In the latest episode of the No Compromises podcast, we rethink our “project standard” repo. Instead of a full Laravel skeleton, we propose a composable library of tool-specific, versioned configs (PHPUnit, Docker, etc.).

We walk through the benefits for greenfield and legacy work, open questions about test organization, and how this approach scales as tools evolve.

DTOs (Data Transfer Objects) aren't mentioned anywhere in the Laravel docs, but some devs use them heavily in their applications, whereas other devs never use them at all.

In the latest episode of the No Compromises podcast, we weigh the pros and cons of DTOs in everyday Laravel apps, comparing them to form requests, PHPDoc-typed arrays, and service-layer boundaries, and share one area where DTOs truly shine.

The takeaway: keep DTOs in the toolbox, but reach for them intentionally, not by habit.

Business change and projects end, but how do you wrap up and sunset an app, especially one you've worked on for years?

In the latest episode of the No Compromises podcast, we share a practical checklist for winding down an app when the whole company is closing. From documenting services and dependencies to deciding what data to retain, we cover backups, credentials, and why deleting local copies matters for security and sanity.

What do you do when you need to create some data but you haven't built out the UI for that data yet? A seeder is a great approach, but is it always the right one?

In the latest episode of the No Compromises podcast, we dive into a real project where starting with the most complex feature made test data management painful. Instead of exploding the complexity of our seeders, we built a minimal UI to manage test data.

We also talk about some other unexpected benefits, and talk through the trade-offs and why detours like this should feel uncomfortable (and be tightly scoped).

Blade gives you two big levers for keeping views maintainable: @include and Blade components.
When should you use one versus the other?
Does it matter?

In the latest episode of the No Compromises podcast, we lay out a clear heuristic for when to extract markup for organization (includes) versus when to encapsulate and reuse with controlled scope (components).

We also touch on scope pitfalls, “passing for documentation,” and why performance worries usually lie elsewhere.

Sign up for the free Mastering Laravel newsletter. The highest value-to-time ratio you will find.

Aaron admits he used to wrap every query in plain old if-statements—until Laravel’s when()/unless() helpers (and arrow functions) won him over. He and Joel compare their journeys, debate readability trade-offs, and share guidelines for deciding which style to use. Along the way they discuss false assumptions, evolving “code grammar,” and how tools such as Rector can automate the switch.

Joel and Aaron compare two very different ways to tackle pull-requests—reviewing them commit-by-commit or scanning the whole thing at once. They dig into when each approach shines, how “atomic” commits can help (or hurt) reviewers, and why understanding how your teammate’s brain works is a super-power. Along the way they share practical tips for leaving yourself notes, spotting hidden changes, and keeping large refactors under control.

Joel and Aaron explain why every project should start in the client’s own GitHub organization—even when the client has never heard of Git. They share scripts, onboarding tips, and war-stories that show how small setup shortcuts turn into big headaches later. You’ll learn a repeatable way to protect both your reputation and your client’s code base.

Joel and Aaron unpack how they use code-coverage numbers as a starting signal rather than a finish line. They discuss realistic thresholds, choosing the right tool for each test layer, and why coverage metrics can double as negotiation leverage inside big organizations. Listen in for practical ways to decide what to test—and when to stop.

Joel and Aaron unpack a recent client project where the only spec was “make these two systems talk.” They share how console-level prototypes helped them clarify data mapping, test tricky scenarios, and keep the client looped in without over-building a UI. If you’ve ever had to code first and document later, this one’s for you.

Joel and Aaron dig into Laravel’s `Stringable` class and uncover how it can silently skip Blade’s automatic HTML escaping. They explain why that’s both a convenient feature and a potential security pitfall if user input isn’t properly sanitized. You’ll hear practical ways to keep your views safe without losing the API’s fluency.

Picking up where last week’s “Why ‘no time’ really means ‘no priority’” left off, Joel and Aaron tackle the next hurdle: what to do once the benefits are crystal‑clear but you (or your team) still hesitate. They unpack the hidden frictions—fear of discomfort, stakeholder pushback, or sheer inertia—that keep valuable tasks on the back burner. You’ll hear a quick mental exercise for elevating true priorities and concrete tactics for transforming “someday” into forward motion today.

Joel and Aaron tackle the common objection, “We don’t have time,” and show why it usually hides a priority problem. They discuss how to convey the true payoff of process improvements by sharing honest before‑and‑after stories instead of vague promises. You’ll leave with practical ideas for getting buy‑in—whether you’re pitching tests, planning habits, or any other change.

Joel and Aaron show how ignoring GET request validation can cause performance issues and open your application to abuse. They highlight the importance of bounding pagination and share tips for using form requests to handle unexpected user input.

Now go check out the best/only Laravel validation book

Joel and Aaron explore why pushing too many layers of abstraction can backfire in a Laravel application. They highlight the benefits of sticking to the framework’s conventions for long-term maintainability and simpler handoff to future developers.

Joel and Aaron explore the decision-making process behind hiring or consulting an expert for technical challenges. They discuss examples like adding tests to a large codebase and understanding what questions you need to ask. They also reveal how coaching can help teams avoid common pitfalls and reach solutions faster.

Joel and Aaron discuss the benefits of having distinct databases for testing and local development. They share how this approach ensures a reliable test suite and avoids conflicts with day-to-day dev work. In the process, they reveal a simpler workflow for setting up new environments and keeping projects stable.

In this episode, Joel and Aaron discuss the struggles of learning new technology on a late-night side project. They share tips for handling frustration and managing expectations.

Joel and Aaron explore the value of using concise video demos instead of long emails or scattered screenshots. They discuss which clients benefit from quick visuals and when text is still best.

Want to see us on camera? Join the Mastering Laravel community for our live dev calls.

Joel and Aaron debate how to structure multi-tenant API requests and tests. They explore the interplay between authentication, tenant headers, and different levels of validation. In the end, they reminisce about old infomercial freebies and wonder if they still exist.

Joel and Aaron explore the nuances of when to venture beyond Eloquent in Laravel applications. They discuss specific scenarios where using lower-level database tools might be necessary, while emphasizing the importance of not abandoning Eloquent entirely. The conversation provides practical insights into balancing framework features with performance needs.

Joel and Aaron dive into a friendly debate about the true nature of feature flags in software development. Drawing from their varied experiences across different programming languages and environments, they explore whether feature flags should always be temporary or can serve permanent purposes. The discussion evolves from a simple disagreement into deeper insights about different architectural approaches.

Ooh, something new was just announced. And I have this project coming up. It could be perfect! But should I use it?

On today's episode of No Compromises, Aaron and Joel share a conversation they had along these lines on a recent client project and considering the new Flux library from the creator of Livewire.

Programmers love geeking out and creating specialized terms and vocabulary. Well I can do that too. In today's episode, we talk about "value objects", put our own special definition on it, and discuss when we might use these in a Laravel project.

Have you ever struggled working with a third party on one of your developer projects? How do you handle that, keeping it professional and also still able to meet your commitments?

In today's episode of No Compromises, Aaron and Joel discuss what happened on a recent project and how they think about handling those kinds of difficulties while still having boundaries.

And if you're looking for help on your Laravel project, get in touch!

JSON fields can be very useful, but when is a good time to include them in your database design?

In today's episode of No Compromises, Aaron and Joel use a couple examples from recent projects to talk through reasons they would and would not use a JSON field.

Static types and tooling have increased the quality of our apps, but sometimes certain features in your Laravel app don't play nicely with static analysis.

In today's episode, we talk about how we approach the tradeoffs around making a tool happy without changing how you write code.

I write a lot about testing in the Mastering Laravel newsletter. Ever wonder why it's a topic I care so much about?

In today's episode, we discuss that question and come up with a few different reasons.

What does it really mean when you say you know a particular technology? On today's episode, we discuss this using TypeScript as a specific example.

Programmers are not shy about telling other programmers when they're wrong. But what can we learn in a situation like his? How can we be wrong with style? In this episode, Aaron and Joel talk about times they've been wrong throughout their career and what they've learned.

We can't know everything, so throughout each day we inevitably have questions. On today's episode, we discuss different approaches we have used when we need a little help.

The dreaded bug report: this app is slow. Ok, but what is slow? I have so many questions!

In today's episode, we discuss our approach to getting more information out of that initial bug report, and a methodical approach to locate and quantify the slowness.

If you'd like help setting up tools like Xdebug profiling, send us a message.

Writing tests that communicate with a third party can be a little tricky, but we've found an approach that balances speed and confidence.

In today's episode, we share that approach and talk through a strategy of how frequently to run tests that talk to the outside world.

I don't have time to write an API spec. We're not a giant team. We don't have external users of our API.

I've said all these things in the past, but in today's episode, we discuss why you should still consider writing a specification for your Laravel API.

Maybe you've tried to add static analysis to your Laravel app and got scared away by all the errors.

In this episode we discuss how we like to introduce PHPStan to large, long-lived projects in a way that doesn't introduce a lot of risk or change.

Would you like help introducing Larastan to your project? That's one of many things we can help you with!

This episode is sponsored by Mailtrap, an Email Delivery Platform that developers love. Try for Free at MAILTRAP.IO

Why isn't this working? It can be frustrating when something doesn't work as expected!

In this episode, we talk through a recent issue Joel had with sessions and oauth flows. There are a couple principles that apply more broadly.

Next time you're stuck on something, let us help!

This episode is sponsored by Mailtrap, an Email Delivery Platform that developers love. Try for Free at MAILTRAP.IO

"Magic" methods and properties show up several places in Laravel, as well as third-party packages. They can make certain things easier and less verbose, but there is a trade off. In this episode, we discuss a few different contexts where we like and avoid magic accessors.

We'd really appreciate it if you share the show with other Laravel devs.

This episode is sponsored by Mailtrap, an Email Delivery Platform that developers love. Try for Free at MAILTRAP.IO

Admins can do everything in the app, right? Today we discuss a couple reasons why you may want to consider not letting an admin have access to every single feature in your app.

🎉️ Episode 100 is a huge milestone for us. Thank you for listening!

This episode is sponsored by Mailtrap, an Email Delivery Platform that developers love. Try for Free at MAILTRAP.IO

Have you ever turned on error tracking in a long-lived app and then got overwhelmed by all the errors happening? We talk through some strategies to not get overwhelmed and make a case that you really should be monitoring this in production.

Would you like help with your legacy app? We have a ton of experience making legacy apps a joy to work within.

We've talked about coding standards before, but this time we approach it from a slightly different angle. Does the way you're code is formatted affect your ability to understand it? Brains are interesting things.

Is your code slower than you'd like? We specialize in Laravel performance optimization and we can help! Contact us to discuss.

You launched a hobby project and then it starts to get some traction. What next? How do you get a more solid foundation under your app when it comes to database hosting? In this episode, we discuss the common phases we see a database go through during an app's life.

And if you'd love some help moving your database or tackling performance issues, give us a call!

Interfaces are a great tool for writing maintainable applications, but it is possible to go "too far" with abstraction. Or maybe, it's a bad use of time to write an abstraction up front before you really know you need it. We discuss some trade-offs and examples.

When you're writing a test it can be so tempting to just "tweak" some app code to make it easier to write that test, but we discuss why that might not be a good idea. We also talk about some app changes while writing tests that are beneficial to the overall project.

Do your eyes glaze over when someone mentions singletons or factories? We'll try to not to be boring as we explain the benefits of design patterns.

Sign up for our free Laravel newsletter and learn something new in 2 minutes or less.

Ever feel like your Blade views are getting too logic-heavy? What logic belongs in the view, and what logic would be better somewhere else? We use a recent PR discussion to talk through these points.

When new tools and packages come out, there is usually some buzz around the launch, and how it solves all the problems of the old tool. Should you switch? How do you know when it's worth it? What are the potential downsides of switching? We talk through a couple examples and share how we approach these decisions

Want to see what our coding standard looks like?

Toss a coin in the jar if you enjoyed this episode. We really appreciate it!

Seeders seem pretty straightforward. It's a way to generate data. But how should you use them in your app and what different purposes do they serve? We talk through our approach to seeders and how we use them in a few different contexts.

Toss a coin in the jar if you enjoyed this episode. We really appreciate it!

Is there some particular tool or technology that just makes you mad? Maybe it's the way CSS behaves or how some browsers work. Don't just get mad, dig in and learn it thoroughly. We talk about how we've done that and how it helped.

Toss a coin in the jar if you enjoyed this episode. We really appreciate it!

We see a lot of different projects, but it's pretty rare to find one that's well-documented and internally consistent. Why does that matter? And how can you make things more consistent without spending a lot of time on it?

How do you like to upgrade your app when the next new major version of Laravel comes out? Aaron and Joel share two different approaches they've used, and what added benefits you get from doing a version upgrade.

Need help getting tests on your Laravel app before upgrading?

We're developers, we write code! But sometimes it's worth thinking if we really need to fire up our editor, or if a better solution exists. We talk through some "behind the scenes" podcast workflow, and how we decided we didn't need to write code this time.

Just about every application needs the concept of roles and permissions. Often, there's a desire to allow non-developers to manage roles and permissions in the application interface, but is that a good idea?

You might have a book that really shaped how you write code today. Some books make more sense if you read them later in your career. We discuss the changing value of books as a learning resource as you gain experience.

00:00 Using books as a resource
01:59 Changing perspectives as you gain experience
03:05 Recognizing real-world applications of what you read
05:45 Balancing enthusiasm with experience
07:20 You don't need to learn everything
09:35 Silly bit

You could spend a few thousand dollars on books, but maybe that money is better spent working with us.

This is a surprisingly controversial topic. In this episode, we share why we write down migration methods, and it's probably not the reason you're thinking of.

It's frustrating to have a client, boss, or even co-worker attempt to micro-manage you. We share some tips on how to make the working relationship better.

Developers spend a large part of their day inside an editor. For a full-featured editor like PHPStorm, there may be some useful features you've never noticed. We discuss a few of those.

PHPStan is a great tool, but if you're not careful it might push you to write code in a way you wouldn't normally write it. How can you balance a tool's strengths with your team's style of writing code?

It is so exciting to watch a conference talk announcing some new tool or feature. Now you're back at work and your fingers are itching to type `composer install` - What do you do?

You like short things, that's why you listen to this podcast. How about a short Laravel tip in your inbox?

Programmers have opinions on things. Shocking, I know! How can we tell someone we think there's a better way to do something, without being counterproductive and causing needless confrontation?

We get a bit nerdy here and dive deep on a few different ways to test record creation.

Do you maintain laser focus when you work, or are you a normal human being? How do you balance use of email and social media for legitimate work reasons without going down the rabbit hole of distraction? Stop your work and listen to this episode for answers. It's not a distraction, it's an investment.

The discussion of final classes was a hot topic recently. We had planned on discussing this even before it came up on Twitter, but here is our unsolicited opinion.

Is there some use case we missed? Aaron wants to hear about it.

Show notes

We always write tests, and can't imagine working without them. But is there ever a time where it might make sense to delay writing some tests until later in the project? Let us tell you a story about a recent project where we made that decision.

Show notes:

Some interviewing techniques can be pretty disrespectful of the applicant's time or humanity. On today's episode we talk about some ways of approaching an interview to put the person at ease and help them to do their best.

Show notes:

Maybe you're a solo dev or working on a small team. What benefits are there in widening your circle of developers? We talk through our own personal experiences in this episode.

Show notes:

We'll admit it: sometimes we change our mind. In this episode, we discuss how we used to setup queues in Laravel tests, and why we changed it.

Show Notes

Want to make us happy with a random email? Check out our free and paid books on masteringlaravel.io

Rules in programming can be extremely helpful, especially on a team. But is it possible to go too far with rules? We discuss a couple recent scenarios where we could have made a rule, but decided not to.

Need help to set up or improve your team's coding standards?

Before you vent some frustration on another tool or programming community, take a deep breath and think about why you're irritated? We talk about our own reactions to some technologies and how it's good to keep an open mind or, at a minimum, to not be a jerk.

Need some help with your Laravel application?

We have such a rich ecosystem of packages in the Laravel and PHP community. But can there be too much of a good thing? What do we consider before adding a small package to our projects?

Would you like help auditing the packages in your Laravel application?

Laravel has a vibrant community of people teaching and sharing what they've learned. What makes a good tip? Should you tweet or blog or both?

Check out the new articles section on masteringlaravel.io

New PHP version! New Laravel version! So exciting! But when does it make sense to upgrade, and when does it make sense to start using new language or framework features?

If you enjoy this podcast, we'd really appreciate help spreading the word. Share it with your fellow PHP and Laravel developers.

How can a bug be fun, and not frustrating? When you treat it like a puzzle. Let's walk through a recent bug with CSV mime type validation and go deep down the rabbit hole.

Why would you validate your MIME types? Learn that and a whole lot more with our validation book: Mastering Laravel Validation Rules

User experience is a term we hear a lot as developers, but it can mean different things depending on the context. We discuss a recent project where decisions around which HTTP status code to return was focused on improving the user's experience and trust in the application.

Move from competent to confident - become a better Laravel developer with the free resources available at masteringlaravel.io

We discuss two "interesting" patterns we've observed in a number of Laravel projects. Let's take a step back and think about why we write tests the way we do.

Need help building a test suite for your Laravel app or making your existing tests more reliable? Click the link and book a free call to see how we can help.

We've all been there: a thorny piece of code works, but it seems like there must be a better way to simplify it or make it more readable. We share one example when this happened to us, and how code review led to a better solution.

Want another set of eyes on your code? We can help! Visit our site and schedule a free call with us today.