Shared Core
The APPNETOS Shared Core is the common runtime environment and orchestration foundation for independent business applications. It provides reusable technical capabilities and consistent architectural conventions without requiring applications to share their business logic, configuration, or infrastructure.
One Core. Unlimited Business Software.
The claim expresses a deliberate architectural choice: one shared runtime foundation can support many independent business applications. Rather than rebuilding common infrastructure for each project, developers can work with established runtime conventions and reusable services.
The Shared Core is not an application and does not represent a central business process. It is the common technical foundation and runtime architecture on which applications operate.
By sharing the same technology stack, teams can maintain common capabilities in one place, apply improvements consistently, reduce duplicated implementations, and move between applications with less onboarding effort.
Shared runtime and technology stack
APPNETOS provides foundational mechanisms for routing, request handling, rendering, security, sessions, database access, caching, and other runtime services. Applications select and configure the capabilities relevant to their requirements.
The shared runtime also orchestrates application execution. It provides a consistent environment while leaving room for application-specific behavior and initialization. Sharing a runtime does not mean every application must activate every available feature.
Shared defaults, application-specific configuration
A central Core configuration can provide common defaults. Applications may adopt those settings or supply their own configuration when isolation, performance, deployment topology, or operational requirements differ.
| Capability | Shared option | Application-specific option |
|---|---|---|
| MongoDB | Common connection and database settings | Dedicated database, MongoDB server, or cluster |
| Redis | Shared Redis configuration | Dedicated Redis connection or instance |
| Database cache | Common cache configuration | Application-specific cache configuration |
| Runtime services | Reuse available common settings | Configure services independently where supported |
This flexibility supports both compact installations with shared infrastructure and larger deployments where selected applications need dedicated resources. The exact configuration files, inheritance rules, and precedence are documented separately under Bootstrap & Configuration.
Reusable building blocks
A shared runtime does not imply shared business logic. APPNETOS nevertheless provides optional reusable building blocks that can accelerate development without forcing applications into the same business model.
- Core Apps: reusable functional and user-interface building blocks, such as forms and navigation elements, that applications can integrate as needed.
- Business Core: reusable business-oriented documents, collections, and domain models for common enterprise concepts such as companies, persons, employees, partners, and warehouses.
Applications remain free to implement their own domain-specific behavior. Reuse is an opportunity to reduce implementation and maintenance effort, not a dependency on an unrelated application.
Domain-driven customization across applications
Customization can provide a shared home for business-domain implementations used by multiple applications. Domain-specific classes, documents, and collections can be organized for reuse instead of being independently recreated in every application.
This allows teams to centralize selected data structures and business rules, reduce duplication, and maintain shared domain behavior more consistently. It does not require all applications to use the same collections or database: integration and data ownership remain explicit architectural decisions.
Class mapping and extensible initialization
APPNETOS supports configurable class resolution and extension mechanisms so behavior can be customized without directly changing the original Shared Core source. Bootstrap customization can also introduce additional components into the application runtime.
For example, a future security application such as appnetos-firewall could be integrated into a
suitable shared initialization path. A dedicated business-oriented extension layer could likewise expose
common domain services to multiple applications. These are architectural possibilities; the exact extension
points, ordering, and security guarantees depend on the implemented bootstrap configuration.
Class mapping, extension precedence, and bootstrap configuration are described in detail in the dedicated Bootstrap & Configuration documentation.
Independent applications, coordinated runtime
The Shared Core is the common runtime environment and orchestrator, while applications provide their own functionality. They may reuse common configuration, Core Apps, and business components to minimize development effort—or supply their own configuration, infrastructure, and customized bootstrap behavior.
The shared architecture enables reuse without eliminating application independence.