Looking for RJSF (React JSON Schema Form) alternative in Express (EJS / server-side)

[nayan-kr7]

Hi everyone,

I’m working on an Express.js application (with EJS templates) and I have a requirement to build forms dynamically using JSON schema.

I’m aware of react-jsonschema-form (RJSF), but it’s React-based and not suitable for my current setup since I’m not using a frontend framework.

Currently, I’m generating forms manually by looping through a JSON schema in EJS, but I’m looking for a more structured or library-based approach that can:

Generate form UI from JSON schema
Support basic validation
Work with server-side rendering (Express/EJS)
Ideally reduce manual template logic

Is there any library or approach in the Express ecosystem that provides functionality similar to RJSF?

Or is building a custom solution (schema + EJS + validation like Ajv) the recommended approach?

Would appreciate any suggestions, best practices, or examples.

Thanks!

[ericgitangu]

Honest answer: there's no mature server-rendered RJSF equivalent in the Node world. JSONForms ships a vanilla renderer set but still expects a JS runtime to mount; SurveyJS works but is heavy and opinionated. Most teams converge on what you're already doing — just structure it.

Pattern that scales well:

1. One EJS partial per schema type (string, number, boolean, enum, object, array), plus widget overrides keyed off a ui:widget field — mirror RJSF's uiSchema convention so you can swap later if you ever move to React.
2. A single recursive render-field.ejs that dispatches on type / format / widget.
3. Ajv 8 with ajv-formats and ajv-errors on POST, compiled from the same schema you render from. Single source of truth for UI + validation is the whole point.

import Ajv from "ajv";
import addFormats from "ajv-formats";
import addErrors from "ajv-errors";

const ajv = new Ajv({ allErrors: true, coerceTypes: true, useDefaults: true });
addFormats(ajv); addErrors(ajv);
export const compile = (schema) => ajv.compile(schema);

<%# render-field.ejs %>
<% const w = uiSchema?.[name]?.['ui:widget'] || schema.type %>
<%- include(`widgets/${w}`, { name, schema, value, errors }) %>

coerceTypes: true is what makes Ajv usable for HTML forms — everything arrives as strings. For nested objects/arrays, render name="user[address][street]" and let Express's built-in qs parser rebuild the tree on POST.

If you outgrow this, layer htmx on top — you get RJSF-style dynamic add/remove of array items via server fragments, no frontend framework required.

[aasimansari1]

For server-side form generation in Express with EJS, there are a few solid alternatives to RJSF:

1. express-form-builder + EJS (simplest)

Build a simple helper that maps a JSON schema to EJS partials:

// formHelper.js
function schemaToHtml(schema) {
  return Object.entries(schema.properties).map(([key, field]) => {
    const type = field.type === string ? text : field.type;
    return `<div class="form-group">
      <label for="${key}">${field.title || key}</label>
      <input type="${type}" name="${key}" id="${key}" class="form-control"
        ${schema.required?.includes(key) ? required : }/>
    </div>`;
  }).join(
);
}
module.exports = { schemaToHtml };

2. uniforms (server-side compatible)

npm install uniforms uniforms-html

Works without React — renders plain HTML forms from JSON Schema.

3. Alpaca.js (EJS-friendly)

Alpaca renders forms client-side from a schema definition — works great with EJS since you just pass the schema as a JSON variable:

<!-- In your EJS template -->
<div id="form"></div>
<script>
$("#form").alpaca(<%- JSON.stringify(schema) %>);
</script>

4. Build it manually with EJS partials (most control)

<!-- views/partials/field.ejs -->
<div class="mb-3">
  <label class="form-label"><%= field.label %></label>
  <input type="<%= field.type %>" name="<%= field.name %>" class="form-control"
    <%= field.required ? required :  %>/>
</div>

For most Express+EJS projects, option 4 gives the most control and keeps dependencies minimal.