808: The Future of JavaScript Frameworks × Building Auth × DB Design Tips, and more!

Episode Summary

Executive Summary: This potluck episode covered the changing JavaScript framework landscape, pragmatic local-dev and API proxying patterns, database design basics, building your own auth stack, JSX composition choices, podcast video distribution, and a handful of practical gear recommendations. The hosts emphasized standards-based, maintainable tooling: React will remain strong, but Solid, SvelteKit, Astro, and web components may gain ground; backend/auth decisions should prioritize portability and ownership; and relational schema design should favor explicit tables and relationships over nested blobs.

Main Topics: Future of JavaScript frameworks: They predicted minimal upheaval overall, but noted React Server Components may push some teams toward alternatives like Solid/SvelteKit/Astro, especially where JSX compatibility and signal-based reactivity are appealing. Web components were also framed as a likely larger part of the UI future. Caddy, local development, and reverse proxies: The hosts explained how Caddy can proxy local apps through clean .localhost domains, preserve cookies/localStorage separation, and solve practical issues like Safari cookie behavior and WebSocket proxying. Proxying third-party APIs through your backend: They argued that most third-party data should be fetched server-side for security, caching, and rate-limit control, though browser-side fetching can be useful when per-IP limits or CORS make it advantageous. Database design and relational modeling: A front-end-heavy listener asked for DB design guidance, and the hosts stressed thinking in terms of one-to-one, one-to-many, and many-to-many relationships, preferring more tables over nested or JSON-heavy structures. Building your own auth stack: The discussion recommended learning auth by implementing it yourself, using familiar frontend tech but focusing on Node/database concepts, and choosing portable request/response abstractions so the work can migrate across frameworks. JSX composition: children vs named props: They compared passing JSX as children versus as named props, with a preference for children when there is a single primary body, but acknowledgment that named props become necessary when multiple slots are needed. Practical tools and merch/sick picks: The episode included recommendations for Loop earplugs and a Gecko’s Toes hose rack for EV charging cables, plus a plug for the Syntax shop, YouTube channel, and podcast video availability.

Key Arguments: React is likely to remain dominant, but React Server Components may create enough friction that some teams reconsider framework choices. Frameworks that support JSX and similar mental models, like Solid and SvelteKit, have an easier path to adoption for React developers. Web components may increasingly replace some custom UI work because they are standards-based and can be consumed without shipping framework-specific versions. Using Caddy with .localhost domains is valuable because cookies, localStorage, and service workers behave more realistically across distinct origins. Most third-party API access should go through your backend so secrets stay private, requests can be cached, and rate limits are easier to control. Sometimes browser-side API calls are better when rate limits are per IP and each end user should consume their own quota. Relational databases are easiest to design when you map real-world relationships first, then normalize nested data into explicit tables. Building auth yourself is educational and practical as long as you follow basic security rules like hashing passwords and using secure cookies. For portability and maintainability, auth/backends should be built around standard web request/response patterns rather than framework-specific abstractions. Children are the cleanest JSX composition model for a single body, but slots would be better than current JSX patterns for multi-part component APIs.

Data Points: Caddy local proxy example port: 7777 - Wes described his Vite server running on port 7777 and being accessed through a .localhost domain. Express app proxy port: 3333 - Wes said his setup also proxies an Express app running on port 3333. ConvertKit cache duration: 1 hour - They used server-side caching of ConvertKit API results to avoid repeated fetches for newsletter data. API rate limit example: 60 requests per hour - They cited GitHub-style per-IP rate limiting as a reason direct client requests can sometimes be preferable. API rate limit example: 60 requests per day - They mentioned some APIs limit usage to 60 requests per day, reinforcing the need for server-side caching. Open-source tee donation: $10 per tee - They noted that proceeds from Drizzle and Prettier shirts go toward open-source projects. Earplug price: $27 - Loop earplugs were recommended as reusable sleep/concert earplugs. JSX platform video availability: Over a year - They said the podcast has offered video versions for over a year. Auth course references: 2 free courses - Scott referenced levelup.video and node auth fundamentals as free resources on building auth.

Pivotal Quotes: "I think that we aren't going to see a whole lot of shakeup, but I do see that now that we're hitting React server components, a lot of people will have not a significant rewrite, but it's a big enough bump in the road where enough of a bump for people to consider moving to something else." — Scott: On the future of JavaScript frameworks and why React Server Components may nudge some teams toward alternatives. "Anytime you're going to be nesting data, err on the side of creating a new table." — Wes: On relational database design, encouraging normalization over nested data structures. "The future of the web is not built on request and connect. That was sort of an older version of it. The new version of it is built on web requests." — Wes: On building portable backend/auth code around standard web request/response abstractions.

Implications: Listeners should expect incremental rather than revolutionary framework change, with more value shifting toward standards, portability, and better tooling patterns. Practical backend ownership, normalization, and proxying strategies remain crucial for security, scalability, and long-term maintainability.