Running RedwoodJS?

RedwoodJS Cells or auth misbehaving? We ship it properly.

Redwood is one of the more opinionated full stack React frameworks, which pays off when the conventions hold and hurts when they break. A Cell that stops resolving, an auth provider that silently returns unauthenticated, or a RedwoodSDK migration that leaves half the routes dead, all land on someone's lap with a deadline attached. We work it back to green.

  • Since 2015Fixing technology
  • FreeEstimates
  • US teamReal engineers

redwood-dev.log

still failing

What it is

RedwoodJS at a glance

RedwoodJS is a full stack React framework that bundles React on the front, GraphQL in the middle, and Prisma on the back, with generators and conventions holding the pieces together. Tom Preston-Werner and the team shipped the first public version in 2020, and the framework has since split into a classic Redwood track and the newer RedwoodSDK, which targets Cloudflare Workers.

The core ideas are Cells, which are files that declare a query and its loading and error states together, and sides, which separate API from web code at the directory level. That makes the framework feel like a well built Rails for React when the generators fit the task, and awkward when your app needs to step outside them.

Type
Full stack React framework
First released
2020 by Tom Preston-Werner and contributors
License
MIT, open source
Maintained by
Redwood core team and open source contributors
Typically used for
Startup MVPs, internal tools, SaaS dashboards, teams that want convention over configuration on React

The honest version

RedwoodJS pros and cons

No technology is all upside. This is where RedwoodJS earns its place and where it tends to cause trouble.

Where RedwoodJS is strong

  • Cells make data fetching legibleOne file holds the query, loading, empty, failure and success paths, so a reviewer sees the full lifecycle without jumping between hooks and components.
  • Generators produce real scaffoldingyarn rw generate scaffold creates pages, cells, services and tests at once, which is useful when you need a working CRUD surface in under an hour.
  • Prisma plus GraphQL out of the boxYou get a typed data layer, resolvers, and SDL files stitched together without picking and configuring four separate libraries.
  • RedwoodSDK pushes toward the edgeThe newer SDK targets Cloudflare Workers and D1 directly, so startups aiming at global latency do not have to assemble that stack themselves.
  • Built in auth providersAuth0, Clerk, dbAuth, Supabase and others plug into the framework through a shared contract, so swapping provider later is less painful than usual.
  • Good Storybook and test integrationComponents, cells and services come with test files pre wired, which quietly raises the floor on coverage.

Where RedwoodJS bites

  • The conventions are rigid when you need to deviateStepping outside Redwood's expected file structure usually means fighting the CLI and the build. A feature that does not fit the generators can take longer than it would in plain Next or Remix.
  • Classic Redwood versus RedwoodSDK is confusingThe project split into two tracks with overlapping docs, and a migration between them is not a flag flip. Teams that chose classic Redwood a year ago now have to decide whether to port.
  • GraphQL is mandatory in classic RedwoodNot every app wants a GraphQL layer, and the framework assumes you do. Adding plain REST handlers or tRPC alongside is possible but goes against the grain.
  • Build and bundle size are not leanA fresh Redwood install carries a lot of dependencies, and API bundle memory during yarn rw build has been a recurring complaint on larger projects.
  • Smaller community than Next or RemixStack Overflow hits, blog posts and job listings are a fraction of what you find around Next.js, so niche questions often end up in Discord or on GitHub rather than a search result.
  • Experimental features churnServer components, streaming SSR and the SDK track have moved quickly, and configuration that worked six months ago may be deprecated or renamed in the current release.

Sound familiar?

Common RedwoodJS problems we fix

The RedwoodJS problems that bring people to us, and what you have once each one is fixed.

Cell: Empty state rendered but data was expected

A Cell never shows real data

A query name mismatch, a resolver that returns null for a non nullable field, or an SDL that drifted from the Prisma schema, so the Empty component renders forever.

Cells resolve, UI renders

AuthenticationError: You don't have permission

The auth provider keeps returning unauthenticated

A session cookie that cannot decrypt after an env var change, a dbAuth secret rotated without updating all environments, or a role check that reads the wrong claim from the token.

Users stay signed in

Prisma P2025

Resolvers crash on missing records

A service calling findUnique where find or findFirst would be correct, so a soft 404 becomes a hard Prisma exception that the frontend has no graceful path for.

Missing data handled cleanly

Out of memory during yarn rw build

Production builds run out of memory

A large API bundle, a dependency graph that pulls everything into one chunk, or NODE_OPTIONS without enough heap set on the CI runner.

Builds complete reliably

RedwoodSDK: Worker cold start exceeded 30s

RedwoodSDK deploys cold start past the limit

A Worker bundle that ships too much code, unbundled dependencies, or a startup path that runs database work on the first request instead of lazily.

Cold starts inside budget

GraphQL: Depth limit exceeded

A GraphQL query is being rejected as too deep

Nested relations that go past the depth limit, often from a UI that follows connections it does not actually need. The right fix is usually the query, not the limit.

Queries fit the policy

redwood.toml deprecated

The project will not start after an upgrade

A redwood.toml with options that have been renamed or removed, or a generator that ran against a newer template than the installed framework version.

Project runs on the target version

drift detected on prisma migrate

Prisma migrations drift from the deployed schema

A hotfix applied by hand to the database, a merged migration that never ran in production, or two branches that each added a migration with the same name.

Schema and migrations back in sync

What we do

RedwoodJS help, from Cells to SDK migrations

Bring us a single broken Cell, or hand the whole project over for an audit.

Rescue
A build that will not complete, a Cell that never resolves, or an auth flow that locks out real users. We get it running before we start explaining.
Cells and GraphQL
SDL and resolver alignment, depth and complexity limits, and pagination that holds up on real production tables.
Auth hardening
dbAuth, Auth0, Clerk or Supabase wired so roles, sessions and refresh behavior match what your product actually needs.
RedwoodSDK migration
Porting classic Redwood apps toward Workers and D1 incrementally, so the team keeps shipping while the move happens.
Performance and bundle
API bundle size, build memory, and cold start times tuned so deploys do not fight the runner limits.
Managed Tech
Upgrades across Redwood versions, Prisma migrations, and a Node engineer on call when the CLI starts refusing a release.

How it works

From first message to fixed

  1. Look Free estimate

    Tell us what's going wrong. We look at it, then tell you plainly what's wrong and what it will cost.

  2. Fix

    We fix the cause, not the symptom. If something is down, getting it back up comes first.

  3. Harden

    Backups, monitoring, updates and access, so the same problem can't quietly come back.

  4. Hand back or stay on

    You get a plain-language write-up. Or we stay on for hosting, upkeep and new work.

Often found together

Running RedwoodJS alongside something else?

We work on the whole stack, so the problem can be wherever it actually is.

Questions

RedwoodJS questions

Something else? Call+1 737 727 7327

Why does my Redwood Cell render Empty forever?

The Empty state renders when the query returns an empty array or null, so the first suspect is the query itself: a field that was renamed in SDL but not in the Cell, a resolver that returns null where it should return an empty list, or a Prisma relation that was never seeded. The dev tools network tab usually tells you whether the API responded with data at all; from there it is a short walk to the fix.

Should we move from classic Redwood to RedwoodSDK?

If your app is already in production on classic Redwood and the team is shipping fine, we rarely recommend porting just because the SDK exists. If you are starting fresh and your traffic pattern benefits from edge compute, the SDK is a reasonable pick. We look at your deploy target, your database, and your traffic shape before giving a straight answer.

Why does our Redwood auth keep failing after a deploy?

Almost always a secret or environment variable mismatch. dbAuth uses an encryption key for the session cookie, and if that key differs between build time and runtime, every cookie decrypts to nothing. Auth0 and Clerk errors are usually callback URL drift or clock skew on the host. We work from the token backwards rather than guessing.

Can Redwood use REST or tRPC instead of GraphQL?

Yes, classic Redwood supports adding plain function handlers alongside GraphQL, and the RedwoodSDK track is more open to non GraphQL patterns. It works but goes against the framework's grain, and you lose Cells for those endpoints. We will tell you plainly whether the tradeoff is worth it for your case.

Why does yarn rw build run out of memory?

Usually the API bundle is pulling more dependencies than it needs, or NODE_OPTIONS on the CI runner is set too low. Raising the heap is the short term fix; trimming the API bundle, excluding server only code from the client, and splitting large services is the durable one.

How much does RedwoodJS help cost?

Our quotes do not cost anything. Share the error output or a description of what Redwood is doing, and you get a price before a single commit lands.

Free estimate

RedwoodJS giving you grief?

Tell us what the CLI or the browser is saying, and a React engineer comes back with a plan and a quote.

  • No charge to find out what it will take
  • If it's urgent, say so

Replies come from a person. By sending, you authorize us to email you back. No marketing.