Neptune EHS: a safety and compliance platform we built from the first commit
- EHS software
- Web platform
- AI
- Product build

- For
- EHS directors, leads and managers, supervisors and workers
- Built
- 2026
- What we built
- The product, an admin console, a demo hub, a host console, the marketing site and the backend
- Stack
- Next.js, React, .NET, PostgreSQL, an LLM API
Neptune EHS brings incidents, audits and corrective actions into one workflow for safety and compliance teams. CodeSwift designed and built it in 2026, from the first backend commit to the launch film. Neptune EHS is a product CodeSwift built, run as a separate company.
The job
Safety teams record what harmed someone, what almost did and what could. They follow up with corrective actions, run audits and inspections, and report injury rates under OSHA rules.
Neptune puts that work in one place: incidents, CAPA, Lockout/Tagout, HazCom, audits and nine more EHS modules in one platform.
What we built
Five front ends on one backend:
- The product. The dashboard safety teams use every day, with 14 modules and access set by role.
- Admin console. Where each company's admins manage their people.
- Demo hub. A space for each prospect, with an overview, assets, an action plan and live chat.
- Host console. Where Neptune's demo hosts manage bookings, availability and hub content, signed in with Microsoft.
- Marketing site. neptunehs.com, with demo booking and rescheduling.
- Backend. One .NET API on PostgreSQL behind all five.

The hard parts
- Three kinds of event, kept apart. An incident means harm happened, a near miss means it almost did, and a hazard means it could. Each is its own module, and a near miss or a hazard can become an incident. One record with a status field would have looked simpler and been wrong.
- Audits and inspections, split on purpose. They started on one shared engine. We split them into separate templates, runs and endpoints, because the work differs even where the screens look alike.
- Injury rates by the book. TRIR and LTIR (total recordable and lost time injury rates) have legal formulas: cases times 200,000, divided by hours worked. The code keeps them exactly as defined.
- Permissions in the token. Each user's permissions travel in their sign-in token, so every screen, and the AI, shows only what that role may see.
- One shape for messy data. The API's responses mix naming styles. A mapping layer turns them into one shape before any screen touches them.
AI where the work happens
- Writing help. On incident, near-miss and hazard reports: proofread, paraphrase and draft, each with undo.
- Neptune AI. A chat that answers questions from the data for the user's own site, such as which corrective actions are overdue at a plant. It works through ten read-only tools, filtered to what that user may see.

How it came together
- 01The backend
- 02The incident module
- 03The product dashboard and the marketing site
- 04The demo hub and the host console
- 05The admin console and AI writing help
- 06The Neptune AI chat and the launch film
Tech stack
Next.js 16, React 19, Tailwind CSS, TanStack Query, .NET 10, Entity Framework Core, PostgreSQL, SignalR, Microsoft Entra ID, Amazon S3, an LLM API, and Remotion for the launch film.