The platform

Your system of record, built with you.

Crift is a platform for building enterprise systems of record, and putting your own name on them. You define the tables, the relationships, the forms, the security, and the rules; Crift renders and enforces all of it, live, without a database project or a release cycle. One foundation, any shape.

Request access Talk to the team →

Not a CRM. The platform you build your CRM on, and call it yours.

One core, any business shape.

Build any system of record

If your business runs on it, you can model it.

  • Create tables, fields, and the relationships between them (customers, contracts, claims, assets, anything) without hand-writing a schema.

  • A new table becomes a live, secured, form-backed part of the system in minutes, not a migration.

  • Customer records, vendor records, case files, deal rooms: managed side by side, in one place.

Underneath: The metadata builder creates and alters entities, attributes, relationships, option sets, views, and forms; each change is projected to real database structure through governed operations.

Design the experience

Every screen, exactly how your team works.

  • Lay out forms with the fields, sections, and tabs your process actually needs.

  • Saved views and filters so each person lands on the records that matter to them.

  • Make a field required, read-only, calculated, or locked-after-create. Each behaves the way the work demands.

  • Add form logic when you want it; if a script ever fails, the form still renders. It can only ever help, never break.

Underneath: Metadata-driven forms with per-placement overrides, structured views compiled to query filters, and a per-form JavaScript engine that degrades gracefully.

Govern who sees what

Security you define, enforced on every record.

  • Build roles with exactly the access each job needs: by table, by record, by action.

  • Three levels (read, contribute, own) composed across a person's roles and teams.

  • Share a single record with a team without opening the whole table.

  • Access requests that get approved, not worked around. Deny-by-default on every operation.

Underneath: Two independent gates, both fail-closed: a record-tier axis composed by MAX across blanket, per-entity, and team-membership grants, and a deny-by-default message-privilege axis.

Make it your brand

Your name on the door.

  • Ship it as your product: your colors, your type, your language.

  • Light, dark, or fully branded; every user's choice follows them across devices.

  • The platform disappears so your brand is what your customers see.

Underneath: A token-based theme system: every surface driven by a swappable palette and type set, persisted per user.

Change it without a rebuild

Change your mind Tuesday, ship it Tuesday.

  • The system is described, not hard-coded. A new field or table is a configuration, not a deployment.

  • Edit the model and the platform reshapes itself underneath it.

  • No migration scripts, no downtime, no engineering ticket for a dropdown.

Underneath: The schema-projection engine turns metadata edits into physical structure on the fly.

Package and move it

Build once, deploy everywhere.

  • Package a configured solution (tables, forms, views, roles, rules) and move it as one clean unit.

  • Dev to test to production, or one client's tenant to the next, without rebuilding by hand.

  • Your configuration is portable because it was always data, never code.

Every change is safe

Powerful to customize, impossible to corrupt.

  • A protected core that customization can never reach, so your changes can't break the platform.

  • Delete is checked first: the system shows you everything that depends on a table before it's gone, and cascades cleanly only when you say so.

  • Every change is recorded (who, what, when) and stamped against the platform's own contract.

Underneath: A boot-time manifest of protected schemas and immutable fields, a dependency scan on every delete, and a full builder audit trail.

Connect everything

If it's in the platform, it's an API.

  • Every table, every action, every record reachable through one consistent interface.

  • A live API specification, generated from your model, so integrations and partners build against the real thing.

  • Add custom actions when a workflow needs more than CRUD.

Underneath: A uniform message pipeline behind every operation, with auto-generated OpenAPI and custom-action endpoints.

Logic without code

Business rules, not engineering tickets.

  • Validation, calculated fields, and roll-ups across related records, configured, not coded.

  • Totals that keep themselves current as the records beneath them change.

  • Rules enforced on the server, so they hold no matter how the data arrives.

Underneath: PowerFx validation strategies, chained computed fields, and relationship roll-ups with reparenting, all running in the write pipeline.

Intelligence built in

The first system of record that reasons.

  • AI isn't an add-on here. It's in the foundation: enrichment, search, and chat with any record, across your data.

  • The same platform that holds your records can map the path through any problem inside them.

  • One foundation, two faces: the system that keeps the work and the engine that thinks through it.

Underneath: A single governed AI gateway and the knowledge-graph reasoning engine layered on the same core.

The power, without the tax.

The power of the enterprise platforms, without the lock-in, the bloat, or the per-seat tax.

Everything you'd configure in the giants, yours to brand and deploy as your own.

Built this decade: AI-native at the core, not retrofitted a product generation late.

One foundation, two faces

The system that keeps the work. The engine that thinks through it.

Crift wears two faces over one core: a configurable system of record your business runs on, and a reasoning engine that maps the way through any problem inside it. Same foundation, same governance, same data.

Build your system of record → See how it reasons →
Request access Talk to the team →