Nucleus replaces five tools — monitoring, audit, security, orchestration, real-time delivery — with one production-tested platform. Plug in your business logic, ship the same week.
Powers 3 multi-tenant SaaS products in production · 17 modules · 866+ tests
Instead, every team rebuilds the same five tools — and spends the first six months wiring infrastructure before writing a line of business logic.
Auth, messaging, audit, monitoring, retries — six months of "platform work" before the product team can ship anything customers see.
Datadog, Vault, OpenSearch, Kafka, your custom audit table — five vendors, five dashboards, no single trace across them.
When a service degrades at 03:00, you find out from Slack — not from your platform. Dashboards show what already happened, not what's happening now.
By the time the request hits your business logic, three sidecars and two service meshes have eaten 40ms. Real-time and high-frequency systems don't have it.
Each team writes its own audit, its own PII masking, its own retention policy. Auditors find the divergence, not you.
New engineers learn five different patterns — one per service the team built — before contributing. Senior time burns explaining, not building.
Nucleus is not a library. It's a production-tested microservices platform with built-in observability, audit, security, orchestration, and real-time delivery — uniformly applied across every service.
One reference architecture across every service. One audit pipeline. One identity layer. One real-time channel. One monitoring control plane. Adopt all five — or just the modules you need.
The capabilities every microservices platform needs — already built, already tested in production.
Know what's happening — not what already happened.
Every service streams health, GC, threads, and custom metrics through your message broker into a unified control plane. Live dashboards. SSE-pushed alerts. Drill-down log explorer that traces one request across every service it touched.
See every step of every request — down to the method.
Three tiers of performance tracking in one console: the gateway times every request live, per-service tracking captures the work inside each service, and @NucleusTracker gives always-on, method-level timing on any method you annotate. Walk a single request through all of its steps — p50/p95/p99 latency, throughput, and error rates on live timeseries charts — then drill from a slow endpoint straight to the method that caused it.
Compliance becomes a one-line annotation.
Add @AuditAction to any method — Nucleus logs who, what, when, with what data. Searchable, exportable, retention-policy aware. Same audit format across every service. Auditors love it. Developers don't think about it.
One identity, one gateway, one place to revoke.
OAuth2/OIDC server with rotating keys. Reactive WebFlux gateway with off-heap blacklist (revoked tokens, blocked users, blocked IPs). Field-level PII encryption. Marker-token verification so backend services reject anything that bypassed the gateway.
Change who can do what — without a redeploy.
Roles, permissions, and route/authority rules live in the database and are managed from the operations console. Grant or revoke access, register and rotate OAuth client credentials, and manage the IP blocklist — all at runtime, fully audited.
Services find each other. You don't write discovery code.
Every service self-registers via broker-published heartbeats. Workflow engine orchestrates async multi-step flows with @WorkflowStep. Restart, shutdown, scale individual instances from one UI. No Consul, no etcd, no extra cluster to operate.
Built for telecom, trading, and real-time systems.
Off-heap Chronicle-Map for hot caches. HMAC over RSA on the request path. Bounded executors with predictable rejection behavior. Async-by-default for side effects with AFTER_COMMIT semantics — sub-200µs platform overhead at p99.
One annotation across every major broker.
@NucleusListener + @NucleusPublish work uniformly across Kafka, RabbitMQ, Solace, Chronicle Queue, SQS, SNS, Kinesis, Google Pub/Sub, Azure Service Bus, ActiveMQ, Artemis, and IBM MQ. Same for the database — JPA over any RDBMS. Switch infrastructure with a config change, not a refactor.
Requests, logs, thread stacks, and GC pauses on one timeline.
Schedule diagnostic windows ahead of time (tonight's 03:00 batch, next Tuesday's release). Every request carries a session ID across every service — scrub the timeline and see the inbound HTTP request, every log line it emitted, the threads that handled it, and any GC pauses that interrupted them, all aligned to the same clock. Auto-archived to MinIO, retention-policy aware.
Not a side project. A platform stress-tested by three live multi-tenant SaaS products handling real customer traffic today.
Nucleus is built on the same primitives high-throughput trading desks and telecom carriers reach for: a pluggable message broker (Kafka, Solace, Chronicle, RabbitMQ — your choice) for durable event streams, Chronicle Map for off-heap micro-second caches, event-driven architecture end-to-end so backpressure stays bounded. The persistence layer is JPA over any relational database — no vendor lock-in.
The framework itself runs on Java 21 + Spring Boot 3.5. Every module ships with Spock + Groovy test specs, an OpenAPI 3.0 contract, and a documented SLO budget. Three live SaaS products — BookWise, GoldFish, TaskSense — run on it in production today.
Adopt one module or the entire platform. The reference architecture stays consistent so onboarding new engineers takes days, not weeks.
Three steps from empty repo to a service registered, audited, and observable.
Add a Maven dependency for the modules you need — nucleus-audit, nucleus-monitoring, nucleus-gateway-client. Write your business logic. That's it.
On boot, the service self-registers with the control plane via your broker of choice. The gateway routes traffic. The audit pipeline attaches. No manual wiring, no service mesh sidecar, no extra cluster.
Health, GC, threads, custom metrics stream live to the dashboard. Audit events flow into the searchable trail. Real-time alerts arrive over SSE. You see it all from minute one.
Where Nucleus is being used in production — and where it fits next.
Startups and product teams shipping multi-tenant SaaS who need a production reference architecture, not another tool stack to integrate.
Real-time signaling, call routing, billing pipelines — sub-millisecond p99 budgets and event-driven architecture from end to end.
Trading, fraud detection, IoT telemetry — anywhere the platform overhead has to stay below the business logic's compute time.
Replacing legacy monoliths and aging ESB stacks with a clean, audited, observable microservices fabric — without the service-mesh tax.
Provider-agnostic LLM routing — switch from OpenAI to Anthropic to a private model with a config change. Multimodal support, retries, error classification built-in.
Finance, healthcare, insurance — built-in audit trail and field-level PII encryption without per-service custom code.
Watch a payments service scaffold, register, audit, and start serving traffic — without writing a line of platform code.
From empty repo to a fully observable, audited, gateway-protected microservice — running in production. Live data, live monitoring dashboard, live audit pipeline.
Nucleus is in production with three SaaS tenants today. Public pricing lands when the managed control plane ships. Get on the early-access list — you'll be among the first 20 teams to onboard, with founder pricing locked in.
Direct line to the architect. Hands-on onboarding. Founder pricing for life.
Replies within 1 business day from [email protected].
See the platform in action with a 30-minute walkthrough. We'll cover your architecture, your latency budget, and what the first sprint looks like.
Or reply within 1 business day · [email protected]