
Is this your show? Claim this page
PodCred
The people behind this show
People get invited back because someone remembered they were great.
PodCred is the verified record of who made this show. A credit here means people who were there confirmed the work.
Hosts
Who is on this show?
Think of the guest you still think about. The producer who makes the host sound smart. The editor who saves every episode. If a name is missing here, that person is invisible everywhere.
Add a creditEpisodes
162 episodesFrom Webmaster to Software Developer in the Age of AI
Have you ever felt a little stung when someone called what you do “vibe coding” as if decades of craft just became optional? In the latest episode of the No Compromises podcast, we discuss why the rise of vibe coding as...
Is the traditional code review workflow holding you back?
Have you ever had someone review your pull request, make changes without telling you, and just merge it in? In the latest episode of the No Compromises podcast, we discuss whether the traditional code review workflow...
Write better requirements or pay for it later
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...
Which layer of caching does your slow app actually need?
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...
Where do credentials end and configuration begin in your env file?
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...
Running AI agents on your production server is the new FTP
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...
Why having a human partner still beats relying on AI alone
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...
What is really inside the AI tools you blindly install
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...
How much logic is too much logic in a PHP enum
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...
Your codebase is not a museum for old code
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...
Do you actually own the code you ship?
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...
Do you actually need a multi-tenancy package?
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...
Local and production should match even for Laravel tools
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...
When weird code needs to explain itself
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...
Are you testing your app or just the framework?
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...
Being anti-hype does not mean being anti-AI
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...
Three ways to plan an upgrade when your codebase is a patchwork
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...
Stop doing math in your config files
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...
What could be worse than having no tests?
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...
Why I changed my mind about down migrations
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,...
Why senior developers feel wrong more often
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...
Should you ever hand-format code?
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...
Discussing different ways to model data
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...
Read outside tech to expand your horizons
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...
Rewriting without a map: shipping an MVP from a legacy app
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,...
A composable, versioned toolkit for Laravel projects
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...
Should you use DTOs in Laravel?
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...
Sunsetting a company app without loose ends
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...
When building a UI makes more sense than bloating your seeders
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...
Blade includes vs components: how we decide
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...
Changing your mind about when() and unless() in Eloquent
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...
Finding a code-review style that fits your brain
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...
Never take hostages: give clients control from day one
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...
Balancing test coverage without chasing 100 percent
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...
Exploratory coding when requirements are fuzzy
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...
Understanding how Stringable works inside Blade views
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...
Finishing up our discussion on not having time
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...
Why “no time” really means “no priority”
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...
When validation can protect your app's performance
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...
Stick with conventions and avoid overengineering your Laravel app
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...
When to bring in outside help
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...
Why two databases are better than one
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...
Dealing with being a beginner again
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. (00:00) - Late-night MicroPython...
Making short demo videos count
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?...
Examining test layering in multi-tenant requests
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...
When to step outside of Eloquent's comfort zone
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...
Feature flags: Temporary tool or permanent solution?
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...
Deciding when to use a new piece of technology
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...
Taking liberties with value objects
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...
How to deal with things outside your control on a dev 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,...
Should we use a JSON field for this?
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...
A balanced approach to static analysis in Laravel apps
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...
Why do we like testing so much?
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. (00:00) - Why do...
What does it mean to "know" something?
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. (00:00) - What does it mean to "know" something? (03:15) - Thinking...
How to approach being wrong
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...
Where do you go when you need help?
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. (00:00) - Where do you go when you need help?...
What does it mean if someone says your app is slow?
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...
Why we have a separate test suite for external services
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...
API specs aren't just for giant teams
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...
Slowly introducing static analysis without changing everything
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...
Troubleshooting an empty session
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...
Magic methods are okay in the right context
"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...
Should you let your admin do that?
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...
Don't get overwhelmed by errors in your application
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...
Does it matter how your code looks?
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...
The life cycle of database hosting
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...
Are you really going to need that abstraction?
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...
Should you change application code to support a test?
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...
What is the point of design patterns?
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...
Move that logic out of your view
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. (00:00) - Trying to...
Is it worth switching to another tool?
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...
How we use seeders in our applications
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...
Don't just get mad at some tech, dig in and learn!
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...
Making a case for consistency
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...
Different approaches to upgrading to a new major Laravel version
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...
Maybe you don't need to write code this time
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...
Should you manage roles and permissions with a UI?
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? (00:00) -...
The changing value of books throughout your career
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....
Some reasons to write a down method in your migrations
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. (00:00) - Is writing down migration methods just a weird...
Managing a micro-manager
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. (00:00) - Uncomfortable projects and clients (02:45) - Ask them...
A couple handy features in PHPStorm
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.
Tools should work for you, not boss you around
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? (00:00) - We...
Harnessing that post-conference excitement
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? (00:00) - Post-conference excitement is...
How do you tell a teammate they might be wrong?
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? (00:00) - Programmers...
Lots of different ways to test record creation
We get a bit nerdy here and dive deep on a few different ways to test record creation. (00:00) - We like testing (01:20) - One way to test creating a record (03:00) - Limitations of fetch the record with first() (05:30)...
How do you avoid distractions?
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...
When should you use final classes or private properties?
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...
Is it ever ok to delay writing tests?
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...
Should an Eloquent relationship include soft-deleted records?
Show notes: (00:00) - Relationships and trashed records (02:00) - One-to-one relationship (02:39) - Are soft-deletes bad then? (03:30) - Balancing end user and developer experience (05:00) - One-to-many relationships...
Interviewing other developers like a human
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...
The benefits of working with other developers
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: (00:00) - Topic intro: the...
Changing our mind about queues in testing
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 00:00 Sometimes we change our mind over time 02:00 Changing queue...
Too many rules?
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. 00:00 I like...
Keeping an open mind with other languages and tools
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...
What we look for in a package
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? 00:00 A healthy ecosystem of...
Blogging versus tweeting
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? 00:00 Why blogging is beneficial 02:43 Slowing down before you publish 04:30...
Knowing when to use new language or framework features
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? PHP marches forward (00:00) Upgrade strategy...
Going on a bug hunt
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. Think of a bug like a fun code puzzle (00:00)...
Thinking about the user, even in the details
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...
Why do you write your tests like that?
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. 1:06 - One weird pattern we’ve seen in Laravel project tests...
Avoid painting yourself into a corner
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...
Look before you leap
Hear about some cool new tool or coding technique on Twitter? Great, jump right in and use it on your biggest production app! Or... maybe don't. We share some thoughts on how to evaluate things critically for your...
Don't plan to do too much
Do you always finish everything you plan on doing? Probably not, very few developers do. The problem isn't always how you work. Some of it is how you plan. We discuss several tips on how to plan for a more successful...
Isolate the problem
What do you do when you're stuck? Aaron shares a tip on how he breaks down a problem when he's feeling stuck. Are you stuck with your Laravel/PHP project? We can help! Book a free call.
What should I test?
We all know we should write tests, but what should we test? Is there anything it doesn't make sense to test? We talk through a high-level approach to how we do feature testing in Laravel. Need some help or advice on...
Posts
No posts yet. Posts No Compromises shares on PodSubs, and what it publishes on Substack, YouTube and its own site, will show here.

Subscribe
Be on the front line of the show
Everything No Compromises sends its own people, first. Resources, announcements, behind the scenes, events, and giveaways, straight from the host. No account needed.
- The resources the host shares with subscribers
- Announcements before anyone else hears
- Behind the scenes from the team
- Events, invitations, and giveaways
- Only what the host sends, nothing else
Audio and video play straight from the show's own hosting. PodSubs stores and serves no media.














