iCMS 4.0 Key Benefits And Upgrades

Build on a foundation designed to evolve

• Object-oriented, namespaced, module-oriented application architecture.
• Managers and list managers encapsulate object behavior and querying.
• Modules act as controllers and reusable administration workspaces.
• Declarative routes define request handling, authentication, access, response type, and other route behavior.
• Handlebars templates keep presentation separate from application logic.

Make changes with clearer contracts and fewer surprises

• Typed PHP parameters, return values, and class properties throughout the modern 4.0 application layer.
• Explicit route and response structures.
• Schema-defined object fields with declared application and storage types.
• Runtime field validation and PHPStan static analysis.
• The same object metadata supports persistence, forms, APIs, validation, editing, and serialization.

Catch regressions before customers do

• PHPUnit test architecture with unit, module, API, integration, and functional coverage.
• Test-aware setup and fixture tooling.
• Static analysis alongside runtime tests.
• Repeatable checks for framework changes, customer upgrades, and compatibility work.

Keep complex services responsive as they grow

• Cacheable object managers and runtime caching.
• Compiled schema information avoids repeated metadata work.
• Compiled template caches accelerate rendering.
• Stored aggregate caches can be refreshed asynchronously by relation listeners.
• Cache behavior stays connected to object and relation lifecycle events.

Model the organization as it really works

• Schema-driven objects can represent members, organizations, applications, courses, projects, products, cases, grants, assets, and other domain concepts.
• Shared object services handle persistence, lists, forms, relations, access, APIs, and serialization.
• Dynamic and language-versioned properties reduce the need for isolated project-specific data layers.
• Business data does not have to be forced into pages, posts, or plugin tables.

Let connections between data carry real meaning

• Relations connect supported object types and can be traversed in either direction.
• Strong relations express ownership, can inherit access from the owner, and can cascade deletion through an owned-object cleanup chain.
• Weak relations express references or associations; their targets survive when an owner or relation is removed.
• Relation listeners can react to saves, deletions, additions, and removals.
• Listener jobs can refresh aggregate caches or run other follow-up work in the background.

Give every person exactly the access they need

• Established ACL levels coexist with granular permission flags for read, create, modify, delete, administer, share, own, and other actions.
• Direct user and group grants model individual and organizational access.
• Defaults and inherited grants reduce repetitive permission maintenance.
• Object and media relationships can propagate access to owned data.
• Modules and APIs use the same underlying permission model.

Protect sensitive information down to individual fields

• Object filters can make fields hidden, read-only, or writable for a relevant user or group context.
• A record can expose public properties while keeping other properties private or role-specific.
• Sensitive schema properties can opt into field-level audit events.
• Configured access and edit events can form a more precise audit trail than a single record-level change log.

Security controls are part of the shared framework, so custom modules can use
the same safeguards as the core CMS.

Protect important accounts with more than a password

• Optional authenticator-app multi-factor authentication using TOTP.
• MFA challenge handling for browser and API login flows.
• Modern password hashing and configurable session handling.
• Hardened cookie options and session-expiry behavior for both browser and JSON clients.

Limit abuse before it becomes disruption

• Shared login-attempt limiting with account and source-IP buckets.
• Configurable Redis-backed request limiting for login, API, upload, integration, or other high-cost routes.
• Standard rate-limit response headers.
• Limits can be tuned by route and deployment risk.

Apply one security model across content, data, APIs, and integrations

• Granular object permissions, user and group grants, defaults, ownership, and inheritance.
• Field-level visibility for public, private, read-only, or editable views.
• Route-level CSRF checks for state-changing module actions.
• Centralized input handling, rich-content purification, and output-aware sanitization.
• Configurable audit events for properties, objects, logins, API failures, integration keys, and rate-limit activity.
• HMAC-signed integration requests using expiring, revocable, scoped keys with optional IP restrictions.

Use the same platform for websites, apps, and headless services

• Generic and feature-specific API routes cover objects, modules, sessions, access data, integrations, events, translation packages, uploads, background status, and controlled object methods.
• API output can respect the same object filters and permissions as server-rendered features.
• iCMS can serve a traditional site, separate front end, mobile experience, internal application, or hybrid delivery model.

Connect external services without accumulating mystery scripts

• Shared provider discovery, configuration, and connection records.
• Encrypted credentials, connection testing, and secure machine authentication.
• Common import/export patterns, operation history, diagnostics, and queued execution.
• Existing integration families cover for example CSV/Excel, Calendar/iCal, translation, cloud storage, messaging, email, business registries, accounting, collaboration, social news, and OpenAI.
• Customer-specific providers can extend the same integration framework.

Keep users informed while work continues in the background

• Server-Sent Events provide a live server-to-browser channel.
• Messages can target users, groups, sites, public audiences, or named channels.
• Backend permission checks constrain channel access.
• Long jobs, notifications, dashboards, and collaborative workflows can update without constant page refreshes.

Automate recurring work without losing visibility

• TaskTimer runs scheduled, recurring, queued, and long-running jobs.
• Use cases include imports, exports, integration sync, translation, media processing, AI, bulk operations, notifications, and site maintenance.
• Administration and APIs expose status, logs, progress, retry or requeue controls, and health information.
• Slow work runs outside the user's request while remaining observable.

Introduce AI as a governed capability, not an uncontrolled shortcut

• AI capabilities can be associated with object types and actions.
• Operations can start manually or from object-level triggers.
• Queued execution supports slow or provider-dependent work.
• Review, approve, reject, and apply states separate generation from live data.
• The framework can support content assistance, translation, structured extraction, classification, image workflows, enrichment, and custom automation.
• AI work can continue to follow platform permissions, object rules, queues,and audit expectations.

Design multilingual services from the beginning

• Language-versioned object fields keep content variants within the same data model.
• Interface strings use named keys and contexts.
• Code-owned string extraction finds translatable application text.
• JSON language packages support import, export, incremental exchange, and legacy-package compatibility.
• Editors can manage content and interface translations in the administration environment.

Let language packs identify and fill their own gaps

• Runtime missing-string tracking records unresolved translations by string, language, and site.
• When automatic translation is enabled, missing entries can queue background suggestion generation without creating duplicate jobs.
• Language-pack hydration processes missing translations in batches through a configured AI, DeepL, or other translation provider.
• Provider output can be staged for editorial review before approval.
• Context filters can limit hydration to the relevant part of the application.

Keep translations consistent across multiple installations

• The language-string integration supports a central publisher and one or more satellite installations.
• Satellites pull complete or incremental JSON language packages from an upstream central language-pack server on demand or by schedule.
• Subscriptions can be limited by language and string context.
• Imports can preserve or overwrite local translations according to the connection policy.
• HMAC-signed integration keys, action scopes, expiry, revocation, and optional IP restrictions protect synchronization.
• TaskTimer runs queued synchronization and records its operation history.

Start with a capable back office instead of building one first

• Administration workspaces cover content, objects, users, groups, permissions, media, templates, forms, redirects, and settings.
• Operational views cover integrations, translations, logs, AI operations, and background tasks.
• Custom modules can reuse shared forms, dialogs, lists, editing routes, and workspace patterns.
• Development effort can focus on the customer's workflow rather than generic administration plumbing.

Create consistent, responsive interfaces without giving up control

• Handlebars/LightnCandy templates separate markup from PHP managers.
• Reusable partials, helpers, structured content areas, and locked template slots support controlled composition.
• CSS framework where components and responsive utilities provide a practical Material Design 3-style toolkit.
• Themes, color schemes, dialogs, and site-level overrides adapt the system to the customer brand.

Handle everyday publishing and application work in one place

• Site structure, pages, content areas, templates, rich text, search, redirects, menus, banners, forms, and users are included.
• Files, images, videos, media folders, drag-and-drop uploads, and chunked uploads share a managed media layer.
• Media selection and media-folder access can follow platform permissions.

Tailor each customer solution without forking the platform

• Shared framework packages remain separate from site-local application code.
• Projects can extend object schemas, business managers, list managers, modules, controllers, traits, routes, and configuration.
• Templates, helpers, themes, assets, API endpoints, integrations, jobs, forms, validators, and lifecycle hooks are also extension points.
• Site-local class loading can extend shared managers and modules at instance level.
• A customer implementation can override only the behavior it needs instead of copying a full shared component or modifying core code.

Manage browser code as a product, not a folder of copied files

• JavaScript and CSS dependencies are declared in a versioned npm package with a lock file.
• Webpack builds shared production bundles; Sass, PostCSS, Babel, minification, and source maps are part of the toolchain.
• Development, production, bundle-analysis, dependency-update, and security audit scripts are provided.
• The iCMS asset builder detects package changes, installs dependencies when needed, builds the shared bundle, and reports generated files and sizes.
• Site-local CSS, JavaScript, and static files can be built into separate instance bundles, preserving customer customization without modifying shared sources.

Move data-model upgrades between environments with confidence

• Object definitions are stored as versioned schemas.
• Schema import can create or update object descriptions and the underlying database structure.
• Schema update compares versions with live database versions and moves the newer definition to the older side.
• Dry-run output shows normalized field, attribute, relation, and index differences before changes are applied.
• Tools support single objects, whole schema directories, missing-only imports, and tenant-specific execution.
• Compiled schema caches can be regenerated and checked for stale or missing metadata after deployment.

Carry language improvements across the whole service estate

• Interface strings and translations use portable language packages.
• Missing strings can be detected and hydrated automatically through configured translation providers.
• A central iCMS installation can publish language packages to satellite installations through the managed language-string integration.
• Satellites can pull packages manually or on schedule, with incremental sync, language and context subscriptions, and configurable overwrite behavior.
• Queued synchronization, operation history, and signed integration keys make the update process observable and controlled.