RedwoodJS with RedwoodJS Core Advocate

Jason interviews Anthony Campolo about the RedwoodJS framework that combines React, GraphQL, Prisma, and conventions to enable serverless SPA development.

Episode Description

Anthony Campolo shares RedwoodJS, a modern full-stack JavaScript framework integrating React, GraphQL, and Prisma for serverless applications.

Episode Summary

This conversation explores how RedwoodJS brings together established concepts, like relational databases and Ruby on Rails conventions, with newer tools such as React and GraphQL. Listeners learn about Redwood’s default serverless setup, which packages an entire project—frontend and backend—into a single function for scalable deployment. The discussion sheds light on how Prisma simplifies database management by offering migration features and a robust “query builder” approach. Attention is also given to Redwood’s tutorial-driven development, a method that guides new users through each piece of the framework in structured steps. Throughout the episode, Anthony shares insights on Redwood’s origins, its connectivity to Rails, and its vibrant community focused on helping contributors gain real-world experience. The result is a unique framework designed for rapid development, simplified deployments, and an inviting environment for developers seeking to bridge modern JavaScript and traditional full-stack paradigms.

Chapters

00:00 - Redwood’s Inspiration and Rails Connections

RedwoodJS emerges from a blend of modern JavaScript frameworks and classic Rails philosophies, showing how a single-page React application can integrate with an opinionated, full-stack toolset. The conversation first highlights Tom Preston-Werner’s past work with Rails and how that experience helped shape Redwood’s focus on convention over configuration. By applying some Rails principles to a JavaScript ecosystem, Redwood aims to provide a structure that speeds up development, unifies frontend and backend operations, and simplifies the creation of new projects. Throughout these initial minutes, Anthony notes the parallels between Redwood and Rails, especially in terms of scaffolding and guiding developers with a well-defined path.

The participants also touch on the idea that Rails has long been known for its robust approach to building monolithic applications, while Redwood aspires to take a similar route in the JavaScript world. Redwood advocates for using React, GraphQL, and Prisma in a tightly integrated manner, preserving the classic “all-in-one” feel. Even though Redwood embraces modern tooling, it maintains the essence of Rails by offering a quick, coherent setup that guides developers from zero to production as efficiently as possible. This alignment with Rails thinking forms the backdrop for Redwood’s approach to structure and design.

05:10 - Redwood’s Project Structure and Client-Server Relationship

As the conversation moves forward, Anthony describes Redwood’s default file organization, splitting applications into a “web” folder for frontend code and an “api” folder for backend logic. This division ensures React components remain separate from the server-side GraphQL and database layers, yet still coexist in one repository. Listeners discover that the web folder can be thought of as a standard React setup, much like create-react-app, while the backend houses Prisma for ORM tasks and a GraphQL server powered by Apollo. Despite comprising multiple technologies, Redwood ties them together with a set of conventions that lower the cognitive load on developers.

Anthony explains that this structure is deliberately designed to give the developer a holistic view without overwhelming complexity. By making React the default choice for UI and bundling the necessary backend code together, Redwood offers a full-stack experience that feels cohesive. Developers can scaffold out resources, write their schema, and manage migrations all within a familiar command-line flow. In these minutes, the conversation underscores how Redwood unifies the modern JavaScript approach to frontend development with the dependability of a strongly opinionated backend, making it easier for teams to collaborate from end to end.

10:20 - Understanding Serverless and Redwood’s Monolith Approach

Here, the conversation focuses on Redwood’s commitment to serverless computing by default. Rather than adopting a sprawling microservices pattern, Redwood packages the backend logic and GraphQL layer into a single serverless function, which scales automatically with traffic. Anthony clarifies how this single-function approach offers cost-effective deployment, since it only runs and incurs charges during actual use. For many developers, it is an attractive way to sidestep complex setup for load balancing and environment management.

This compact serverless architecture also sets Redwood apart from frameworks that require more hands-on attention to runtime environments. By consolidating application code into one function, Redwood achieves a monolithic design within a serverless model, making it simpler to reason about the entire stack. This chapter sheds light on how Redwood’s architecture aligns with modern development needs: it preserves high-level organization but offloads heavy lifting, such as continuous server processes, to a managed infrastructure. As a result, even large-scale applications can benefit from a configuration that is both cost-efficient and straightforward.

15:30 - Deployment, Netlify, and Database Integration

Attention then turns to practical steps for deploying Redwood apps in production. Anthony describes how Redwood is often paired with Netlify for seamless frontend hosting, where the entire site can be generated as static assets and served globally. Meanwhile, the database typically lives on a separate service such as Heroku Postgres, creating a simple two-part setup that covers storage and application logic. Environment variables tie these pieces together, ensuring the GraphQL server and Prisma know which database to query.

Although this structure may seem complex at first, Redwood’s scaffolding commands and clear documentation reduce friction. Developers learn to appreciate how Netlify’s build pipeline, combined with a relational database service, offers a lightweight yet robust launch path. This deployment model is especially relevant for small teams, startups, or side projects that aim for quick iteration while benefiting from enterprise-grade reliability. With each layer working in harmony, Redwood significantly shortens the distance between coding and going live.

20:40 - Prisma, Relational Databases, and Redwood’s Future

Prisma becomes a focus in this segment, presented as a powerful ORM bridging the gap between JavaScript objects and relational data. Anthony compares Prisma’s functionality to Rails’ Active Record, noting its migration tools, model definitions, and query API. Prisma’s evolution hints at a future where it can support both SQL and NoSQL databases, meaning Redwood-based applications could one day swap in MongoDB or other stores without a massive rewrite. This adaptability underscores Redwood’s broader philosophy of integrating proven tools while leaving the door open for innovation.

The discussion also revisits the importance of relational databases, given that many newer JavaScript developers initially learn about document stores like Mongo. Redwood adopts a more traditional stance, defaulting to relational databases for reliability and established scaling patterns. In doing so, Redwood positions itself as a bridge for JavaScript engineers eager to adopt a more classical architecture. By marrying modern React frontends to stable SQL backends, Redwood aims for a balance that addresses both developer ergonomics and production-grade performance.

25:50 - The Redwood Tutorial and Community Culture

Next, listeners discover Redwood’s unique approach to documentation and education through a dedicated, comprehensive tutorial. Anthony highlights “tutorial-driven development,” where framework features evolve hand in hand with instructional materials. This ensures that newcomers can learn Redwood in a sequenced, step-by-step manner, gaining confidence in each part of the stack. The strategy mirrors older Rails tutorials in its depth but is crafted by Redwood’s own core team, ensuring alignment between official documentation and real-world best practices.

Community inclusiveness is another focal point. Redwood actively welcomes contributors, from those just learning web development to seasoned engineers seeking an alternative to sprawling microservices. Anthony’s own journey exemplifies how contributing to Redwood can open doors in one’s career, sparking connections and showcasing tangible skills. Emphasis is placed on collaboration and mutual support, as people from varied backgrounds come together to enhance Redwood, share knowledge, and grow as developers. This spirit of openness is central to Redwood’s identity.

31:00 - Final Insights and Lessons for Developers

In the final segment, the conversation centers on Redwood’s position within the broader landscape of web development. By striking a balance between Rails-style conventions and modern JavaScript tooling, Redwood provides a structured yet progressive environment that appeals to those tired of stitching various libraries together. Its serverless foundation and smooth integration of React, GraphQL, and Prisma can help new projects sidestep many scaling or architectural pitfalls from the outset. Anthony suggests that whether teams choose Redwood’s built-in web folder or pair its API with another frontend, its flexibility remains an asset.

Concluding remarks reinforce that Redwood is more than just a tech stack—it’s a growing ecosystem where active community members guide its evolution. Rails veterans may recognize familiar patterns, while JavaScript aficionados can appreciate Redwood’s forward-thinking approach. Overall, Redwood stands as a welcoming option for those aiming to build serverless single-page applications with clean conventions and clear guidelines. This closing discussion invites curious developers to explore Redwood’s tutorial, join the community, and experience firsthand how it seamlessly unites old and new methodologies.