TanStack Query v5: Why I Replaced SWR in All My Projects

Introduction

This is a deep-dive article on TanStack Query vs SWR. Modern web development moves fast, and staying current with the latest tools and patterns is essential for shipping production-quality software.

Why This Matters

Understanding the fundamentals behind this topic will help you make better architectural decisions, write cleaner code, and build software that scales without becoming a maintenance nightmare.

// Example: clean modern PHP code
class UserService
{
    public function __construct(
        private readonly UserRepository $users,
        private readonly CacheInterface $cache,
    ) {}

    public function findByEmail(string $email): ?User
    {
        return $this->cache->remember("user:{$email}", 300, fn() =>
            $this->users->findByEmail($email)
        );
    }
}

Core Concepts

Before we dive into the implementation details, let's make sure we're aligned on the core concepts. This will make the rest of the article much easier to follow.

• Concept one — the foundational idea that everything else builds on
• Concept two — how the pieces fit together in practice
• Concept three — where most developers get tripped up

Real-World Implementation

Theory is great, but let's look at how this works in a real codebase. The following examples are pulled directly from production code:

// Production-ready pattern
#[Fillable(['name', 'email', 'role'])]
class User extends Model
{
    public string $displayName {
        get => $this->username ?? $this->name;
    }

    public bool $isActive {
        get => $this->status === 'active' && $this->email_verified_at !== null;
    }
}

Performance Considerations

Whenever you're making architectural decisions, performance should be part of the conversation from the start — not bolted on as an afterthought. Here are the key metrics to track and the techniques that move the needle.

"Premature optimisation is the root of all evil, but that doesn't mean you should ignore performance entirely." — Donald Knuth (sort of)

Conclusion

We've covered a lot of ground in this article. The key takeaways are: start simple, measure before optimising, and always write code for the next developer who has to maintain it (that's usually future you).

Have questions or a different approach? Drop a comment below — I read and respond to every one.