JavaScript Developers Dump Edge Stacks as Vanishing VC Subsidies Bite

Interview with Senior JS Developer 2024 [NEW] — Kai Lentit

Kai Lentit

Drying venture capital subsidies are forcing engineers to abandon zero-cost edge architectures and revert to traditional persistent servers and enterprise stacks.

AI-assisted summary of Interview with Senior JS Developer 2024 [NEW] — original source. Check the original for full context.

Source published:

Key ideas

  • Modern JavaScript full-stack templates diverge between web-centric stacks like T3 (Next.js, Tailwind, NextAuth, Prisma) and edge-native, mobile-first alternatives like T4 (Tamagui, Expo, Drizzle, Hono). (0:00)
  • Edge deployments using Hono, Drizzle, and Cloudflare Workers offer zero-cost scale in theory, but face practical constraints around Cloudflare's strict 1 MB worker bundle limit and physical write replication latency. (1:13)
  • Desktop engineering is pushing back against Electron's bundled Chromium memory footprint, increasingly looking to Rust-powered shells like Tauri that rely on platform-native webviews. (4:03)
  • The evaporation of venture capital subsidies in 2024 is reversing the industry shift toward complex serverless setups, prompting developers to reconsider traditional persistent servers and legacy LAMP patterns. (4:03)

Detailed notes

## Background Published by Kai Lentit on YouTube on April 14, 2024, this video is a satirical technical interview titled "Interview with Senior JS Developer 2024 [NEW]." According to the page description and show notes, it features Jack Borrough as a senior developer skewering modern JavaScript trends, full-stack templates like the T3 and T4 stacks, and the broader state of front-end and back-end web development.

## TL;DR A technical job interview quickly devolves into an exhaustive critique of contemporary web architecture as a senior developer contrasts the T3 stack (Theo, Tailwind, Prisma) with the cutting-edge T4 stack (Tamagui, Drizzle, Hono). The discussion cuts through cross-platform mobile styling, Prisma bundle bloat, edge worker scalability on Cloudflare, and dependency sprawl. After evaluating native desktop runtimes like Electron versus Tauri and nostalgically longing for the simplicity of a classic LAMP stack, the interviewer confronts the reality of post-VC funding constraints and operational panic over Kubernetes. Ultimately, the candidate and interviewer abandon edge-computing ideals in favor of a standard enterprise stack, closing with a deadpan public service announcement for exhausted engineers.

## Atmosphere & style The sketch delivers a deadpan, hyper-cynical parody of technical hiring, driven by an authoritarian interviewer who rapidly steamrolls the bewildered candidate with opinionated dogma and rapid-fire jargon. Its pacing feels manic and claustrophobic, oscillating between razor-sharp critiques of real developer tooling and unhinged associative rants about cloud hosting economics. The emotional arc captures the acute fatigue of the modern JavaScript ecosystem—shifting from arrogant framework evangelism to bleak existential dread before abruptly cutting to a sitcom theme song.

## Bulletin - [00:00](https://www.youtube.com/watch?v=aWfYxg-Ypm4&t=0s) Modern JavaScript full-stack templates diverge between web-centric stacks like T3 (Next.js, Tailwind, NextAuth, Prisma) and edge-native, mobile-first alternatives like T4 (Tamagui, Expo, Drizzle, Hono). - [01:13](https://www.youtube.com/watch?v=aWfYxg-Ypm4&t=73s) Edge deployments using Hono, Drizzle, and Cloudflare Workers offer zero-cost scale in theory, but face practical constraints around Cloudflare's strict 1 MB worker bundle limit and physical write replication latency. - [04:03](https://www.youtube.com/watch?v=aWfYxg-Ypm4&t=243s) Desktop engineering is pushing back against Electron's bundled Chromium memory footprint, increasingly looking to Rust-powered shells like Tauri that rely on platform-native webviews. - [04:03](https://www.youtube.com/watch?v=aWfYxg-Ypm4&t=243s) The evaporation of venture capital subsidies in 2024 is reversing the industry shift toward complex serverless setups, prompting developers to reconsider traditional persistent servers and legacy LAMP patterns.

## Key takeaways - [00:00](https://www.youtube.com/watch?v=aWfYxg-Ypm4&t=0s) The T3 and T4 stacks share foundational technologies—Next.js, TypeScript, and tRPC—but diverge in their runtime platforms, styling systems, and design philosophies. - [00:00](https://www.youtube.com/watch?v=aWfYxg-Ypm4&t=0s) T4 supports native mobile compilation out of the box with React Native and Expo, while T3 primarily targets browser-based web applications. - [00:00](https://www.youtube.com/watch?v=aWfYxg-Ypm4&t=0s) Tailwind's integration with React Native required community workarounds like NativeWind, which only stabilized after its creator joined Expo in 2023. - [01:13](https://www.youtube.com/watch?v=aWfYxg-Ypm4&t=73s) NextAuth lacks built-in mobile support, forcing engineers to adopt managed alternatives like Clerk or hack raw REST endpoints. - [01:13](https://www.youtube.com/watch?v=aWfYxg-Ypm4&t=73s) Prisma is burdened by runtime inefficiency and bundle bloat, in contrast to Drizzle ORM, which runs cleanly within lightweight edge environments. - [01:13](https://www.youtube.com/watch?v=aWfYxg-Ypm4&t=73s) Scaling an application on Cloudflare's free edge tier via Hono requires the entire bundled artifact to remain strictly under the 1 MB threshold. - [02:46](https://www.youtube.com/watch?v=aWfYxg-Ypm4&t=166s) JavaScript dependency chaining continuously expands bundle sizes through utility libraries, state management churn, WebSockets, and analytics packages. - [02:46](https://www.youtube.com/watch?v=aWfYxg-Ypm4&t=166s) Venture-funded hosting platforms like Vercel, PlanetScale, and Railway face developer pushback over mounting operational costs compared to low-level cloud workers. - [02:46](https://www.youtube.com/watch?v=aWfYxg-Ypm4&t=166s) Edge-based SQLite databases remain fundamentally limited by the speed of light and physical latency constraints during write replication. - [04:03](https://www.youtube.com/watch?v=aWfYxg-Ypm4&t=243s) Desktop applications built on Tauri drastically reduce device RAM usage by replacing bundled Chromium instances with native operating system webviews and Rust-compiled WebAssembly. - [04:03](https://www.youtube.com/watch?v=aWfYxg-Ypm4&t=243s) Traditional LAMP architectures with PHP and MySQL avoided modern tooling overhead, but demanded direct responsibility for security patches, backups, and operational maintenance. - [04:03](https://www.youtube.com/watch?v=aWfYxg-Ypm4&t=243s) Despite ongoing innovation in edge runtimes, standard production environments frequently fall back to enterprise stacks combining Next.js, Apollo GraphQL, TypeScript, Supabase, and AWS.

## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=aWfYxg-Ypm4&t=0s) T3 vs. T4: Theo, Tamagui, and the Mobile Styling War

The technical interview opens briskly as the senior developer reviews the candidate’s CV, setting aside standard resume bullets to focus on what he considers the true measure of engineering competency: evaluating and selecting modern JavaScript frameworks. He immediately pits two prevailing full-stack templates against each other: the T3 Stack versus the T4 Stack. While both options share foundational technologies—Next.js, TypeScript, and tRPC—the interviewer sharply draws cultural and architectural distinctions between them. As the senior developer frames it: “Both use Next.js, TypeScript, and tRPC, but the T in T3 stands for Theo, a skater boy from California, whereas the T in T4 stands for technology.”

The debate quickly shifts to styling and multi-platform support. T3 relies on Tailwind CSS, which boasts an established community of nearly 5,000 members holding court on Discord, compared to the modest 584 “Tamaguchis” on the Tamagui Discord. Yet the interviewer favors the cutting-edge momentum of Tamagui, noting mockingly that while Tailwind’s last commit was a week ago, Tamagui developers “push on save.” Furthermore, while T3 remains centered primarily on browser-based web applications, T4 compiles out-of-the-box to mobile via React Native and Expo.

The senior developer recounts the turbulent history of styling parity across platforms: Tailwind does not natively map 1:1 to React Native, prompting community efforts like `tailwindcss-react-native`, later rebranded to NativeWind once it gained stability. Although NativeWind went unmaintained for an extended stretch, it achieved smooth React Native compatibility after its author joined Expo in 2023, rendering the old platform incompatibilities obsolete.

```mermaid flowchart TD accTitle: Comparison of T3 and T4 Stacks accDescr: Visual flow comparing the styling, platforms, auth, and database layers of the T3 and T4 JavaScript stacks.

subgraph Core["Shared Foundations"] NextJS["Next.js"] TS["TypeScript"] TRPC["tRPC"] end

subgraph T3Stack["T3 Stack (Theo)"] Tailwind["Tailwind CSS"] WebPlatform["Primary: Web"] NextAuth["NextAuth / Clerk"] Prisma["Prisma ORM"] end

subgraph T4Stack["T4 Stack (Technology)"] Tamagui["Tamagui Styling"] CrossPlatform["Native Mobile (Expo / RN)"] LuciaSupabase["Supabase / Lucia Auth"] Drizzle["Drizzle ORM"] end

Core --> T3Stack Core --> T4Stack ```

- **Stack foundations**: Both T3 and T4 incorporate Next.js, TypeScript, and tRPC. - **Discord community sizes**: Tailwind hosts 4,994 members online, whereas Tamagui counts 584 users. - **Cross-platform delivery**: T4 compiles natively to mobile through Expo and React Native; T3 required NativeWind adaptations following author th3xdev’s hiring by Expo in 2023.

---

[01:13](https://www.youtube.com/watch?v=aWfYxg-Ypm4&t=73s) Auth, ORM, and Edge Scaling: Prisma Bloat vs. Drizzle and Hono

Turning to backend persistence and authentication, the interviewer outlines the friction points inherent in the T3 stack. T3 relies on NextAuth (Auth.js) or its managed counterpart, Clerk. While NextAuth is framework-agnostic on paper, it does not support mobile clients out of the box, forcing developers to resort to `clerk-expo` or reverse-engineer NextAuth's internal REST endpoints. Worse still, NextAuth fails to execute cleanly inside lightweight Hono edge workers on Cloudflare's free deployment tier.

Prisma, the default ORM in T3, draws intense criticism for runtime inefficiency and excessive bundle footprint. Describing its heavy database querying behavior, the interviewer highlights how an unoptimized engine fetches and revalidates entire JSON trees even when matching records sit in the very first row. The interviewer dismisses the ORM's footprint with a cutting workplace jab: “Because Prisma bloats the package just like this company's HR department.”

By contrast, T4 utilizes Drizzle ORM paired with Supabase or a Lucia authentication branch capable of targeting any arbitrary database adapter. Because Supabase and Lucia run natively on the edge, bundling them within a Hono runtime on Cloudflare theoretically allows an application to scale infinitely for zero dollars—provided the entire deployment artifact remains strictly below the 1 MB Cloudflare Worker threshold. When the interviewee tries to interject and ask whether Drizzle could simply be used inside T3, the senior developer cuts him off with an aggressive "Silence," justifying the omission by pointing out that T3 Drizzle documentation has not even been written yet, while Lucia support in T3 remains unconsidered because he has not personally tested it.

- **Mobile auth workarounds**: NextAuth mobile integration requires either switching to Clerk via `clerk-expo` or hacking the exposed NextAuth REST API. - **Edge performance criteria**: Cloudflare Workers running Hono can scale indefinitely at the $0 tier, provided total bundle size remains under 1 megabyte. - **ORM query characteristics**: Prisma triggers broad table and JSON revalidations regardless of index match location, contrasting with Drizzle's lean edge compatibility.

---

[02:46](https://www.youtube.com/watch?v=aWfYxg-Ypm4&t=166s) Bundle Bloat, Hosting Arbitrage, and the Edge of Glory

The discussion spirals deeper into the sprawling ecosystem of auxiliary JavaScript packages and dependency management. T4 leverages lightweight utilities such as Valibot, Million.js, PrettyCake, VirtualEdit, and Jotai. If one were to expand T3 to match this functionality, the interviewer argues, they would immediately need to layer in real-time WebSockets via Pusher or its self-hosted alternative Soketi, alongside privacy-oriented analytics like Plausible and Umami. Redux would be evicted in favor of Zustand, only for Redux to be reintroduced the moment the community abandons Zustand. The cascading avalanche of dependencies inflates application bundles to absurd dimensions, which developers then celebrate inspecting with `@next/bundle-analyzer` and bundle reduction utilities.

The conversation turns to cloud infrastructure and hosting economics. Standard T3 deployments land on Vercel or database platforms like PlanetScale, which the interviewer rejects as venture-backed cash cows. Shifting to Railway merely mimics Heroku, which is now dismissed as enterprise bloat under Salesforce ownership. Delivering a stream-of-consciousness diatribe on hosting logic, the senior developer declares: “Vercel with a V, like in Evil. And Evil with an E, like in 'Emacs is life'. And 'Emacs is life' with a C, like in free hosting on Cloudflare.”

Deploying T4 directly onto the Cloudflare edge promises limitless scale at zero cost—so long as large production codebases like Slack could hypothetically be squeezed under 1 megabyte. The true operational constraint then shifts from raw compute to edge database write operations. Although embedded SQLite resides physically on the edge, the latency of physical write replication remains fundamentally capped by the laws of physics. The senior developer dismisses Cloudflare’s perpetual marketing promises of sub-lightspeed latency by noting that despite recurring roadmaps, next week’s upcoming "Cloud and Innovation Week" promises to change everything.

- **Frontend utility sprawl**: Modern stacks chain libraries like Valibot, Million.js, and Jotai, complemented by Soketi/Pusher WebSockets and Umami/Plausible analytics. - **Hosting cost escalation**: Commercial PaaS platforms (Vercel, PlanetScale, Railway/Heroku) are passed over in favor of Cloudflare edge workers to escape vendor cash-cow traps. - **Physical edge constraints**: Edge SQLite read-write performance remains bound by distributed write latency, regardless of recurring edge marketing cycles.

---

[04:03](https://www.youtube.com/watch?v=aWfYxg-Ypm4&t=243s) Ecosystem Rewrites, Tauri vs. Electron, and Returning to the LAMP Stack

Faced with mounting JavaScript fragmentation, the interviewer explores alternative single-page and meta-framework architectures, riffing on Vue with Nuxt, SvelteKit, SolidStart, and Qwik, accompanied by made-up ecosystem packages like Vue Croissant, Next Beefy, and Svelte Wasabi. Rather than suffering the complete lack of code reuse between these frameworks, the candidate suggests rewriting the entire application directly in Rust. The interviewer initially welcomes the thought, only to retract his enthusiasm:

``` Candidate: "Good idea." Interviewer: "I didn't say anything." ```

For native desktop distribution, the interviewer rejects Electron because packaging a bundled Chromium instance and Node runtime drains device memory. Industry staples like Slack, Spotify, Discord, Office suites, and even Avira Free Antivirus all ship on Electron, but the interviewer mandates Tauri. Because Tauri provides a Rust wrapper around the operating system’s native webview and can execute Rust-compiled WebAssembly, it slashes client RAM consumption. He sums up T4’s marketing hype—type-safe styling, edge runtimes, code sharing, lean bundles, and a purple marketing page—only to concede that industry adoption stubbornly sticks with Tailwind anyway.

In an exhausted moment of reflection, the interviewer looks back at legacy architectures: spinning up a classic LAMP stack with PHP, MySQL, and jQuery on a $5 server once satisfied users without complex deployment overhead. However, maintaining that environment demands active server configuration, security patches, and backups. As the senior developer ruefully admits regarding his own operational track record: “This of course would require backups, server management, security, which I know how to do, but they lost trust in me after our fourth user data cleanup this month.”

He observes that the tech industry is ironically reverting from serverless architectures back to traditional persistent servers in 2024 because venture capital subsidies have evaporated. Glancing around their company's abandoned office lease, he abruptly abandons the T4 edge architecture and decides to build with an enterprise soup of Next.js, Apollo GraphQL, TypeScript, AWS, and Supabase. When asked how Kubernetes fits into this picture, he freezes in dread. The segment closes with a deadpan public service announcement addressed to senior engineers drowning in modern web development frameworks, culminating in an abrupt cut to the theme song from *The Jeffersons*.

- **Desktop shell trade-offs**: Electron bundles an entire Chromium engine; Tauri leverages platform-native webviews via a Rust core to minimize RAM consumption. - **Serverless trends**: The pendulum swing from serverless back to traditional persistent servers in 2024 is attributed directly to dried-up venture capital funding. - **Default enterprise stack**: Despite edge framework theory, the real-world fallback defaults to Next.js, Apollo GraphQL, TypeScript, Supabase, and AWS.

## Mentioned Kai Lentit, Jack Borrough, Theo, T3 Stack, T4 Stack, Next.js, TypeScript, tRPC, Tailwind CSS, Discord, Tamagui, React Native, Expo, NativeWind, NextAuth, Clerk, Hono, Cloudflare, Cloudflare Workers, Prisma, Drizzle ORM, Supabase, Lucia, Valibot, Million.js, PrettyCake, VirtualEdit, Jotai, Pusher, Soketi, Plausible, Umami, Redux, Zustand, @next/bundle-analyzer, Vercel, PlanetScale, Railway, Heroku, Salesforce, Emacs, Slack, SQLite, Vue, Nuxt, SvelteKit, SolidStart, Qwik, Vue Croissant, Next Beefy, Svelte Wasabi, Rust, Electron, Chromium, Node.js, Spotify, Avira Free Antivirus, Tauri, WebAssembly, LAMP stack, PHP, MySQL, jQuery, Apollo GraphQL, AWS, Kubernetes, The Jeffersons

## Video description Javascript programming language

Rust part soon on ?: https://www.patreon.com/ProgrammersAreAlsoHuman JS Stack merch: https://www.redbubble.com/i/sticker/SATAN-stack-by-posix/160332098.EJUG5

Interview with a Javascript developer with Jack Borrough - aired on © The Javascript 2024. more backend advise on https://www.youtube.com/watch?v=y8OnoxKotPQ

t4 stack: https://t4stack.com/ t3 stack: https://www.youtube.com/watch?v=Uj1ykZWtPYI

Programmer humor Javascript humor Programming jokes Programming memes Javascript Js memes js jokes react webassembly next.js, typescript, trpc T3 Stack tailwind tamagui T3 Stack on Mobile State of Javascript 2024 Junior Frontend Job Interview

#programming #jokes #javascript

[Source](https://www.youtube.com/watch?v=aWfYxg-Ypm4)

中文简报

风投补贴退潮冲击下，JavaScript开发者纷纷放弃边缘技术栈 风投补贴的枯竭正迫使工程师放弃零成本边缘架构，重新采用传统的持久化服务器与企业级技术栈。 在一场技术面试中，资深开发者对比了T3栈（Theo、Tailwind、Prisma）与尖端的T4栈（Tamagui、Drizzle、Hono），面试迅速转变为对当代Web架构的全面审视。讨论深入探讨了跨平台移动端样式设计、Prisma打包体积膨胀、Cloudflare上边缘Worker的可扩展性以及依赖项蔓延等问题。在评估了Electron与Tauri等原生桌面运行时，并怀旧地感慨经典LAMP栈的简单性之后，面试官直面后风投时代的资金紧缩现状以及对Kubernetes运维的恐慌。最终，应聘者与面试官放弃了边缘计算的理想，转而选择标准的企业级技术栈，并以一段面向疲惫工程师的冷面公益公告收尾。 现代JavaScript全栈模板分化为以Web为中心的技术栈（如T3：Next.js、Tailwind、NextAuth、Prisma）与边缘原生、移动优先的替代方案（如T4：Tamagui、Expo、Drizzle、Hono）。 (0:00) 虽然基于Hono、Drizzle和Cloudflare Workers的边缘部署在理论上能提供零成本扩展，但面临着Cloudflare严格的1 MB Worker打包大小限制以及物理写入复制延迟等现实约束。 (1:13) 桌面工程领域正在抵制Electron捆绑Chromium所带来的内存占用，越来越多地转向依赖平台原生Webview的Rust驱动外壳（如Tauri）。 (4:03) 2024年风投资助的蒸发正在扭转行业向复杂无服务器架构迁移的趋势，促使开发者重新考虑传统的持久化服务器和传统的LAMP模式。 (4:03)

Original transcript

[0:00] So the CV looks all good and everything, [0:01] but it all comes down to how fit you [0:03] are with selecting JavaScript libraries. [0:05] Imagine we had two options, [0:08] the T3 and the T4 stack. [0:11] Both use Next.js [0:12] TypeScript and tRPC. [0:14] But the T in T3 stands for Theo, [0:17] a skater boy from California. [0:19] Whereas the T in T4 [0:21] stands for technology. [0:23] Now T3 uses Tailwind, while T4 uses Tamagui. [0:27] Tailwind has a huge community [0:29] of 4994 hodlers online in the Discord, [0:32] versus 584 Tamaguchis. [0:34] But the Tamaguchis are more cutting edge. [0:37] Where the last commit for Tailwind was last week, for Tamagui. [0:41] We push on save. [0:42] T3 is primarily focused on web apps, while T4 is immediately cross platform. [0:46] Because T4 natively compiles to mobile, [0:49] as React Native, through Expo. [0:51] Now Tailwind doesn't map 1:1 to React Native... [0:53] but the T3 stans [0:54] have tried for a long time to get it compatible with: [0:57] tailwindcssreactnative. [0:59] Which was renamed to native-wind [1:00] once it started working... [1:02] which was abandoned for a long time But was made compatible with react native after its developer [1:07] "th1xdev" ...joined expo in 2023. [1:09] And now it's fully compatible with mobile anyways [1:12] to forget this whole part... [1:13] Now the real problem [1:15] comes in when we look at Auth and ORM. [1:17] t3 uses next-auth or it's hosted solution clerk. [1:20] Now next-auth is framework-agnostic, [1:22] but it doesn't work on mobile. [1:25] We could of course use clerk-expo [1:27] to make it work on mobile... [1:28] or hack the next-auth.js-exposed REST API. [1:33] And see where things go. [1:37] But even if we fixed the NextAuth client, [1:39] NextAuth also doesn't work with hono-workers [1:41] for free edge deployment on Cloudflare. [1:43] t3 also uses Prisma, which is super inefficient and ugly. [1:47] I mean, just try a simple query. [1:49] If your result is in the first row in the first JSON, [1:52] it will still revalidate every row in every JSON. [1:54] Now t4 uses SupaBase for userdata [1:56] and sells it to the darknet. [1:58] But there is also a Lucia branch for this, [2:00] which works with any ORM or database. [2:02] ...If you know how to write the adapter. [2:05] Now Lucia and SupaBase work on mobile flawlessly. [2:09] Now instead of Prisma, t4 uses Drizzle. [2:13] Straight out of the gate. [2:14] SupaBase and Lucia are edge- compatible, [2:16] which means if we deploy on Hono, [2:19] can scale to infinity and beyond for $0... [2:22] if our bundle size is under 1mb. [2:25] Which is also we cannot use Prisma. [2:28] Because Prisma bloats the package [2:30] just like this company's HR department. [2:34] Now Drizzle also works on the Edge. [2:36] Yeah, but couldn't Drizzle just? [2:37] - Silence. [2:38] Drizzle could work on T3, [2:39] but the documentation hasn't been started yet. [2:42] Now, Lucia would also work with T3, but I haven't tried that, [2:45] so I'm not going to consider. [2:46] Now, T4 also uses helper libraries [2:48] like ValidBot, MillionDollarJS, [2:51] PrettyCake, VirtualEdit, and JotUi. [2:53] Now, we could, of course, [2:54] extend T3 with those, [2:55] but we would first extend T3 with Pusher [2:57] for WebSockets. [2:58] Actually, better to use Soketi. [3:00] And plausible and umami for analytics, because [3:03] Google Analytics is Google Analytics... and we would also add Zustand to abandoned redux [3:07] from our vocabulary - just to reintroduce it [3:09] once they abandon Zustand. He. JavaScript. [3:11] All of this creates an insanely huge bundle, [3:14] which we're lucky to expand with [3:15] bundle reducers and NextBundleAnalyzer. [3:18] I love it. [3:18] Now, t3 would typically host on Vercel, which is a cashcow, so [3:22] it's better to use planet scale... which is a cashcow, so it's better to [3:25] use railway, which is like Heroku, which is now owned by Salesforce. And therefore evil. [3:30] Vercel with a V, like in Evil. [3:32] And Evil with an E, like in "Emacs is life". [3:34] And "Emacs is life" with a C, like in free hosting on Cloudflare. [3:37] T4, we will just host straight on the edge. [3:40] Of glory. [3:41] Which means if we can get Slack to compile under 1mb, then we can [3:44] scale it to infinity for $0. [3:48] The only bottleneck then is our database. [3:50] Not even the database, but the write ops. [3:52] SQLite is by definition on the edge. [3:54] But it's still slower than the speed of light. [3:55] Cloudflare says they're working on that. [3:57] They say that every week. [3:58] But next week is Cloud and Innovation Week. [4:00] So next week is different. [4:02] Now we don't have the source of Slack anyway. [4:03] So, now we could of course rewrite the whole stack. [4:06] From ReactNext to Vue Nuxt. Svelte and Sveltekit [4:09] Solid and SolidStart. [4:10] qwik and Kwik-E-Market. [4:11] And each comes with their own whole ecosystem. [4:13] Like Vue Croissant [4:15] Over Next Beefy or svelte Wasabi To reuse 0% of our code. [4:19] Don't write this down, next week all of this is gonna change. [4:21] So. [4:27] But then again, we might as well rewrite straight to Rust. [4:29] Good idea. [4:31] I didn't say anything. [4:32] Now the backend we can compile to WebAssembly and host on Worker-rs for free. [4:36] The frontend? [4:37] Now for the desktop app supporting the React webcode, [4:40] we would need a native webview. [4:42] We would use Tauri because Electron is bloated and ships its own Chromium. [4:46] Now Tauri is basically like a V8 running. [4:49] What is V8? [4:50] Exactly. [4:51] Spotify, Slack, Discord, *beep* Office. [4:55] And most importantly, avira free antivirus. [4:58] All use Electron. But we will use Tauri, because while Electron is a compiled app [5:02] with a webview that can render Rust compiled webassembly, [5:05] Tauri is a Rust app. [5:06] And we save on RAM. [5:07] So T4 has 1000% code sharing, performance, production-readiness, [5:12] performance, lean optimized bundle size, free hosting on Hono Runtime [5:16] edge-workers, cutting edge, performance, 1000% type safe styling, [5:20] free hosting, a purple landing page, but everybody uses - performance - [5:24] Tailwind. [5:25] So, [5:30] you know, years ago, we would just set up a PHP and SQL in a LAMP stack [5:33] on a 5 server with jjquery. [5:37] And our 5 users would be happy. [5:39] But this of course would require backups, server management, security, which I know [5:43] how to do, [5:44] but they lost trust in me after our forth user data cleanup - this month. [5:48] In fact, everybody's changing back to servers. [5:50] 2024 is the year of the serverlesslessness. [5:53] They said that 10 years ago. [5:54] They say that every year, but this year, they're out of VC funding. [5:57] We have an entire abandoned office building, so might [6:00] as well go with JavaScript. [6:01] So we would use Next.js [6:03] Apollo GraphQL, TypeScript, AWS, and Superbase. [6:13] What is Kubernetes? Ah. [6:16] I know this might seem like a fun way to spend your time in the age of AGI. [6:23] But this is the public service announcement [6:25] to all senior engineers trying to learn all of this in online courses [6:26] to get a job in today's developer market. [6:30] My advice to you is [6:40] Fish don't fry in the kitchen *Song starts*