A high-level guide to the capabilities that matter when evaluating RunicCore — what each feature does for your teams, and when it is the right fit.
Overview
RunicCore is an enterprise microservices framework for teams that need secure APIs, durable multi-step processes, and a consistent lifecycle from local development through production operations.
This documentation is a conceptual orientation — not an API reference. Use it to understand the key capabilities, decide whether the framework fits your architecture goals, then explore the product page and public repository for deeper evaluation.
When to use RunicCore
You are standardizing how microservices are built across product teams
You need protected client–server traffic without inventing a custom security stack
You run multi-step business processes that must survive real-world failures
You want one consistent lifecycle for build, test, and day-2 operations
Key features at a glance
Four capability areas cover the hard parts of enterprise services — so product teams spend less time rebuilding platform plumbing.
Sensitive payloads stay protected as your services scale — without every team inventing its own crypto path.
RunicCore treats protected client–server traffic as a first-class capability. Requests and responses travel on encrypted paths with modern cryptography and forward secrecy, so confidential data is not left to ad-hoc middleware or one-off integrations.
Teams can apply stronger controls where risk is highest — registration, rate limits, and route-level policy — while keeping a consistent developer experience across services.
What you get
End-to-end encrypted transport with forward secrecy
Hardened request handling and sanitization
Pluggable policy for registration and rate limits
Device-aware auth hooks when clients need stronger assurance
Especially useful when
APIs that carry personal, financial, or regulated data
Mobile and web clients that must trust the server path
Platform teams enforcing a minimum security baseline
Distributed workflows
Multi-step business processes that keep going when the real world gets messy — retries, coordination, and clear outcomes included.
Long-running work rarely fits in a single request. RunicCore’s workflow capability lets you define a process once and run it across a fleet with durable execution, scheduling, and coordination built in.
Operators and product teams get a clear picture of run status — what started, what finished, and what needs attention — instead of piecing together logs from half a dozen services.
What you get
Durable multi-step process execution
Fleet-friendly coordination and leadership
Clear run outcomes for ops and product teams
Scheduling and execution controls you can operate in production
Especially useful when
Onboarding, approvals, settlements, and other multi-party processes
Work that must resume after failures or restarts
Teams that need shared operational language for process state
Service foundation
The everyday building blocks of enterprise services — so every project does not re-solve the same bootstrap problems.
Beyond security and workflows, services still need HTTP bootstrap, sessions, localization, validation, structured logging, and configuration. RunicCore packages these as a coherent foundation instead of a pile of optional plugins.
The result is a consistent service shape across teams: faster onboarding, fewer one-off conventions, and fewer gaps when services move from prototype to production.
What you get
Typed service bootstrap and production-ready HTTP stack
Auth gateway patterns and session lifecycle
Structured logging with trace context
Built-in validation, localization, and configuration patterns
Especially useful when
Platform groups standardizing microservice templates
Product teams that want defaults without fighting the framework
Organizations reducing glue code and bespoke starter kits
CLI & operations
One lifecycle surface from local development through day-2 operations — less script sprawl, more repeatable delivery.
Frameworks fail in production when every team invents its own build, test, and run story. RunicCore centers a single CLI surface for the common lifecycle so developers and operators share the same commands and expectations.
Local loops stay watch- and debug-friendly, while process lifecycle hooks stay production-minded — so the path from laptop to production is deliberate, not improvised.
What you get
Unified build and test commands
Watch and debug friendly local loops
Production-minded process lifecycle hooks
Faster onboarding with fewer bespoke scripts
Especially useful when
Engineering orgs tired of N different Makefile traditions
Teams that want day-2 operability designed in, not bolted on
Leads evaluating total cost of ownership beyond the demo
Who it's for
RunicCore is built for teams that treat platform quality as a product requirement — not a side project.
Platform teams standardizing how microservices are built
Product engineering groups that need secure APIs without a custom security stack
Ops-minded developers who want workflows and observability as defaults
Architecture leads evaluating frameworks for multi-year service estates
Whether you are evaluating RunicCore, exploring pHub, or planning a custom enterprise system, start with the architecture and operating requirements that matter to your team.