/**
* ING CRM — customizable CRM platform, frontend core
* @author Roshan Aryan Majhi · core contributor
*/
One schema.
Every view.
ING CRM lets organizations define their own objects, fields, pipelines, and workflows at runtime — then renders those records as kanban boards, data tables, and rich detail pages generated from the same schema. I shipped frontend features across its first production cycle as one of ~10 contributors.
// design_system
System first, screens second.
color/tokens
primary
#3A6FEF
green
#00C072
purple
#9374EC
red
#F2454B
orange
#F0943F
stroke
#222427
type/scale
Aa
Inter Variable
Heading 20
Body 14 · relaxed
mono 11 · boards & tables
radius/0.625rem
cards lg · stage pills full
components/ui
{ "deal_value": "currency", "stage": "pipeline_stage", "close_date": "date", "owner": "user_relation", }
view all →
// Optimistic everything await moveDeal(deal, stage); // card moves before the round-trip queryClient.setQueryData(["deals"], (old) => …); await api.mutate(); // rolls back on error
// before: hand-written memoization - const columns = useMemo( - () => buildColumns(props), - [props] - ); // after: the compiler does it + const columns = buildColumns(props);
+53 more in package.json
opens the exact filters, for anyone with access
// why_it_exists
A CRM that adapts to the business, not the reverse.
Most CRMs hard-code their worldview: leads, deals, a fixed set of fields. Teams bend their process to fit the tool - spreadsheet exports, shadow trackers, abandoned configurations.
ING CRM flips that. Admins model their own domain at runtime: custom object types, typed property groups, pipelines and lifecycle stages with probability weighting, and associations linking any object to any other. The frontend never heard of your entities - it reads the schema and builds the UI from it.
// feature_modules
What ships inside.
dynamic_objects_engine
The core. Admins create object types with typed property groups, pipelines, and lifecycle stages; records of any type flow through generic list, board, and detail views generated entirely from metadata.
record_views
Every object gets a virtualizable data table, a drag-and-drop kanban board, and a deep record page with profile, notes, comments, and activity - all reading one query layer.
intake_pipeline
External submissions enter through configured connectors and sources, then get triaged on an infinite-scroll board before becoming first-class records.
bulk_operations
Bulk edit, delete, and transfer with a selection toolbar that adapts to whatever mix of records and property types is currently selected.
global_search
A command-palette search across all object types that respects per-property searchable flags - admins decide what findable means, the search obeys.
realtime_layer
Notifications arrive over Laravel Echo + Pusher websockets, mirrored to browser push via a service worker - triage keeps moving when the tab is in the background.
access_control_auth
Teams, users, roles, and granular permissions — plus login hardened with TOTP two-factor auth and single-use recovery codes.
// engineering_decisions
Worth noting.
- +React Compiler in production - automatic memoization instead of hand-written useMemo, keeping a 60k-line app honest about re-renders.
- +Views live in the URL - table filters, active pipeline, and board grouping serialize into query params - any view is shareable and refresh-safe.
- +Optimistic drag-and-drop - kanban moves apply instantly and reconcile against the mutation, because a board that waits feels broken.
- +One component tree for every object type - dynamic columns, filters, and forms resolve from property metadata at render time, not per-entity code.
- +A real editing surface - notes and comments run on a custom Tiptap stack with mentions and bubble menus, not a drop-in WYSIWYG.
// my_role
What I built.
Second-largest contributor by commit volume on a ten-person team, shipping features from Figma handoff through production across the platform's first release cycle.
$boards_and_intake
- Kanban board for intake submissions, with infinite scroll over large queues
- Drag-and-drop stage movement with optimistic updates
- List / table / board view switching shared across object types
$pipelines_lifecycle
- Pipeline & lifecycle-stage management: create, reorder, inline edit, search
- Stage validation with probability weighting
- Conditional rendering driven by object capability flags
$properties_associations
- Property group and field CRUD, incl. archive / unarchive / restore flows
- Record associations - link, unlink, restore - with stable list/detail states
$search_bulk_ops
- Global search honoring per-property searchable flags
- Bulk edit & bulk delete with dynamic selection toolbar
- No-data / empty-state system across admin surfaces
// in_one_line
A build-your-own CRM where the schema is the product — and the interface generates itself from it.