Philosophy

Durable and Future-Proofed

Your platform should be built to last. Large organisations cannot afford to rebuild every few years because a stack, structure, or editorial model failed to age well. Lucidity.js is designed around durable patterns, stable foundations, and modern tooling that can evolve over time, so your platform remains maintainable, adaptable, and useful long after launch.

We've worked closely with Sanity solution engineers to ensure Lucidity.js can use all of Sanity's features, now and in the future. That includes Sanity Create, the App SDK, the Content Agent, and the new Media Library, as well as anything more Sanity throws at it.

Scalable

Your platform must scale organisationally as well as technically. Scale is not only about performance or traffic. It is also about supporting more teams, more locales, more content, more workflows, and more operational complexity over time. Lucidity.js is designed to help organisations grow their digital estate without the platform becoming harder to manage, govern or evolve.

Governable

Your platform should be easy to govern at scale. Central teams need visibility, consistency, and control, while regional and local teams need enough freedom to do their work effectively.

Lucidity.js is designed to make governance practical, with clear roles, workflows, permissions, and content structures that help organisations maintain quality without creating unnecessary bottlenecks. These can be customised on a per-site level, or easily shared between several sites, giving you granular control without complicated management.

Delightfully Integrated

Everything must work seamlessly together, in a way that exceeds your expectations. Your platform must feel like a joined-up system, not a collection of disconnected decisions. Lucidity.js has designed the editorial experience with intention. We've spent time sweating the small stuff, and that can be felt within the platform.

Configurable and Extendable

Your platform must adapt to your organisation, not force your organisation to adapt to it. It must reflect how your organisation actually works. You may have your own structures, teams, approval models, content responsibilities, and operational realities. Lucidity.js must be able to support these, so the platform can support the business more naturally instead of forcing awkward workarounds

Lucidity.js is designed to be configurable so it can support different teams, markets, workflows, and technical requirements. And where configuration alone isn't enough, Lucidity.js is designed to be extendable to give your organisation flexibility where you need it.

Ownership

Your platform should be easy for new developers to understand and take ownership of. Teams change, suppliers change, and internal capability changes over time, so a platform that only makes sense to its original builders becomes a liability.

Lucidity.js is designed with clarity, consistency, and maintainability in mind, making it easier for developers to inherit, extend, and support with confidence. There is rich documentation on this website, as well as within the codebase itself, and Sanity, React, and Next.js provide their own detailed documentation and learning courses.

Safe

Your platform must be safe to operate. That includes technical security, reliable delivery, sensible handling of permissions and secrets, integration with your other security and governance tools, and patterns that reduce the risk of accidental breakage or inconsistency.

Lucidity.js is designed from the ground up with a focus on security to provide strong foundations and safe defaults. We take care of the security best practices, so you're airtight from day one.

Derisk

Overall, Lucidity.js is designed to lower the operational and strategic risk that comes with large digital estates by giving teams a durable, scalable, governable, high-quality, and safe platform out of the box. It comes with sane defaults, clear boundaries, and a path from simple implementation to enterprise-grade delivery.

This reduces the chances of inconsistency, fragile implementations, duplicated effort, and expensive rework as your platform grows.