How We Built Gamers Vault: Real Talk About Our Tech Stack
· 6 min read
So we built a gaming social platform. Here's what we used and why—no BS, just the actual decisions we made and what we learned along the way.
Next.js 15 Because... Well, It Made Sense
We went with Next.js 15 and React 19. Look, we're not going to pretend this was some groundbreaking decision—Next.js is kind of the obvious choice these days if you're building something with React and want decent SEO.
The Server Components thing is actually pretty cool though. You can grab data right on the server and skip sending all that JavaScript to fetch it client-side. Does it make the app faster? Yeah. Did it also confuse the hell out of us for the first week figuring out what's a server component vs client component? Also yeah.
Supabase: Because We Didn't Want to Deal With Auth
Real talk—we picked Supabase because building your own auth in 2025 is kind of insane. Why would we spend weeks on OAuth flows, password resets, and session management when someone's already solved it?
Plus you get a Postgres database, real-time updates, and file storage all in one. Is it perfect? No. Have we occasionally fought with their TypeScript types? Absolutely. But it beats managing our own database server.
One thing we learned the hard way: always use getUser() to validate auth server-side, not just the session cookie. Trust me on this one.
Caching Everything Because API Calls Cost Money
We went a bit overboard with caching, honestly. Four different layers:
- Upstash Redis for the really important stuff
- Next.js's built-in cache (which is... fine)
- Standard HTTP cache headers
- TanStack Query on the frontend
Is it overkill? Maybe. But when you're pulling game data from third-party APIs and every call costs something, you get religious about caching real quick. Game details sit in cache for 30 minutes, and honestly, we might bump that up.
Cloudinary for Images (Because Images Are Annoying)
Gaming platforms = tons of images. Game covers, screenshots, user avatars—it adds up fast.
We use Cloudinary basically as our image middleman. Upload once, and it handles all the WebP conversions, different sizes for mobile vs desktop, and delivers everything through their CDN.
Could we have done this ourselves? Sure. Would it have taken forever and probably worked worse? Yep.
Security Stuff (The Boring But Important Parts)
We added all the standard security headers—CSP, CSRF protection, rate limiting, input sanitization. Not gonna lie, most of this was just copy-pasting from security checklists and MDN docs.
The rate limiting happens through Upstash—10 requests per minute per endpoint. Some users hit it and complain, but it keeps the API costs down and stops obvious abuse.
The TypeScript Situation
Strict mode TypeScript everywhere. No any types allowed (okay, there's probably a few hidden in there, but we try).
Is it more work upfront? For sure. Does it save time catching stupid bugs? Also yes. We auto-generate our types from the Supabase schema, which is both convenient and occasionally frustrating when the generated types don't match what we expect.
What Actually Matters
Here's what we've learned building this thing: pick good tools and get out of your own way.
We didn't build our own auth, our own image CDN, or our own database. We just wired together a bunch of services that are better at those things than we'd ever be. That left us time to actually build the parts that make Gamers Vault interesting—the social features, the challenge system, the game library stuff.
Is our stack perfect? No. Are there things we'd change? Sure—we're already eyeing some alternatives for a few pieces. But it works, it's fast enough, and most importantly, we can actually maintain it without wanting to flip a table.
Bottom line: Modern web dev is less about building everything yourself and more about knowing which services to stitch together. We're basically just well-paid Lego builders at this point.
Have questions about any of this? Hit me up. Always happy to talk shop about what worked, what didn't, and what we'd do differently next time.