There's a temptation to treat slow refresh times as a purely technical puzzle, but the real story here is about how data environments behave differently for different people. The original poster has done the obvious work, optimizing queries, cleaning up SharePoint files, enabling fast load, and still watches the same report take 30 to 60 minutes on their machine while colleagues finish in five to ten. That gap is not a mystery to be solved by more code cleanup. It's a signal that the bottleneck lives outside the query itself, in the invisible handshake between your machine, your credentials, and the way SharePoint negotiates access.
When ten users hit the same data source and only two experience extreme delays, the difference rarely comes down to laptop specs or raw internet speed. It comes down to session state, caching, and how the data source authenticates each user. SharePoint often treats per-user connections differently, especially when files are synced, cached locally, or accessed through OneDrive. The two slow users may be pulling data through a less efficient path, or their local cache may be stale, forcing the system to revalidate permissions and re-download metadata that other users already have stored. The fact that the poster and one other user share the problem is telling, it points to a pattern, not a random glitch.
The practical move is to stop treating this as a query-tuning issue and start treating it as an access-path issue. Ask the fast users what they see on their end. Are they opening the file from a synced folder or through a direct SharePoint link? Are they signed into OneDrive with the same account that accesses the data? Are they running the report from a cached copy while the slow users trigger a fresh pull every time? These details matter more than any single query optimization. The poster should also test clearing the local cache, signing out and back into all Microsoft services, and ensuring the data source is accessed via the same URL pattern for every user, mixing `sharepoint.com/sites/` paths with direct file paths is a classic way to split performance down the middle.
The real lesson here is that speed is not just a function of the query, it's a function of the entire path from the user's keyboard to the data. Two people can run the same file and live in different data realities. The fix is to make the path identical for everyone, or at least understand why it isn't. So before rewriting more code, audit the access. Compare sessions, clear caches, standardize the connection string, and test with a fresh profile. That's where the minutes are hiding.