Beyond Basic Eloquent Eager Loading: Optimizing Deep Relationships?

Hey everyone, hope you're all doing well. I was on here a while back asking about persistent N+1 issues with complex relationships in Laravel 10, and thanks to some great advice, basic with() and load() helped a ton in tackling those initial bottlenecks. We saw some good improvements in our app's Eloquent performance after implementing those changes, which was awesome. However, as our application grows and user traffic increases, we're hitting new walls, particularly on pages with deeply nested relationships. Think Order -> Item -> Product -> Category -> Manufacturer type scenarios. While basic eager loading was a lifesaver for direct relationships, it's becoming really unwieldy and frankly, not cutting it for these more complex, multi-layered data fetches. We're still seeing noticeable performance bottlenecks on certain reports and user dashboards, especially where we need to display a lot of related data. We've tried a bunch of things to keep our Eloquent performance up. Of course, we started with with() for direct relationships, which is standard practice. Then we moved to nested with(['item.product.category']) to pull in deeper data. We also explored loadMissing() and load() for conditional loading when we only need to fetch relationships if they haven't been loaded yet. For aggregated data, we considered withCount() to avoid loading full collections, which helped a bit in specific cases. We even looked into select() to limit columns, but this sometimes complicates eager loading by requiring us to explicitly select foreign keys or other necessary columns. And, honestly, for some really complex reports, we've even resorted to raw DB::select() queries, which feels like abandoning Eloquent entirely and is definitely a last resort for us. The main issues we're facing now are a few things. First, deep nesting leads to very long Eloquent eager loading chains which become incredibly hard to manage, debug, and understand as the codebase evolves. It's just a lot of mental overhead. Second, sometimes we need to load only some related data based on conditions in the parent model or even within the relationship itself, and making standard eager loading work with those specific conditions is proving difficult. Third, memory consumption is increasing significantly, especially with larger datasets and many eagerly loaded relationships, which is a big concern for scalability. It feels like the problem isn't just N+1 anymore, but rather the sheer volume of data being loaded and processed, impacting overall Eloquent performance. So, my specific question to this amazing community is: what are some advanced strategies or best practices you've found for optimizing deeply nested Eloquent relationships beyond just simple with()? Are there specific packages out there that help manage this complexity, or perhaps architectural patterns that lend themselves better to these scenarios? I'm also open to database-level tricks, like using views for pre-joining specific datasets, if that can integrate well without completely abandoning the convenience and developer experience of Eloquent. We really want to keep our Eloquent performance at its best without losing the benefits of the ORM. Help a brother out please, any insights would be massively appreciated!