Under the hood of SimpleOne: a full technical overview of the platform architecture

SimpleOne is an enterprise Low-code platform built to automate service-based business processes and develop full-fledged business applications. This article is written for technical specialists, solutions architects, and software engineers who want a look under the hood of the platform’s technical design.

We’re going to unpack the SimpleOne architecture, the tech stack, and the engineering choices made along the way — from programming languages to deployment models.

Detailed product information can be found in our multi-language documentation.

Technology Stack and Architecture

Overall Architecture

The SimpleOne backend relies on a hybrid architecture, pairing the monolithic core with microservices written in Golang and Node.js. This is supported by the GenAI platform layer, which makes it easy to plug various AI models directly into your business processes.

On the frontend, the platform is built with TypeScript, using React library and MobX for state management.

When it comes to executing custom, user-defined scripts, the platform is powered by the V8 JavaScript engine.

Infrastructure Components

Database

The primary data store for the platform is PostgreSQL. However, given that enterprise environments are complex, for specific edge cases and unique client requirements, integration is possible with external data sources.

Caching

The platform relies on Redis. It pulls double duty, acting as both a high-speed cache and an in-memory data store (for example, handling authorization tokens inside the API Gateway). 

Message Brokers

Under the hood, RabbitMQ and Kafka manage the event-driven architecture, ensuring smooth, asynchronous message processing across the platform.

Deployment

The entire platform is containerized using Docker.

Delivery Specifics

SimpleOne is delivered as Docker images, suited for on-premise deployments on a customer’s own infrastructure.

The platform is also available as an offline distribution — archives containing all necessary Docker images that can be fully deployed in "air-gapped" environments without internet access.

Working with Data

The Data Model

SimpleOne comes out-of-the-box with pre-defined primitive data types that can be used when adding fields to tables. These types are pre-populated and ready to be used in configurations immediately..

SimpleOne handles complex relational data, supporting all standard table relationships with no impact on performance:

• Reference (foreign keys linking to other records);
• Many-to-Many (M2M) via junction tables;
• One-to-One;
• One-to-Many.

The tables at SimpleOne also support inheritance — meaning child tables automatically inherit fields from their parent tables. This gives the flexibility to build highly complex, hierarchical data structures and spin up a massive number of tables without taking a hit on query performance.

The REM Approach

One of the standout architectural choices of SimpleOne is REM (Record Extended Model). This is a dynamic schema extension approach, conceptually similar to the classic EAV (Entity-Attribute-Value) model. Traditionally, if there is a need to add custom attributes to a specific request type, the database schema usually requires alteration by creating a new child table. REM bypasses this entirely. It stores those custom attribute values in a separate, dedicated table and links them to the primary record only when necessary.

SimpleOne leans on REM extensively in its ITSM, ITAM, and B2B CRM products, and the approach is currently being tested for SDLC and HRMS. It’s an incredibly efficient way to handle complex systems at massive scale — especially in large enterprises where highly flexible service catalogs and dynamic request routing across different departments are required.

Data Integrity & Transactions

Every database write operation happens within a transaction. If an error occurs during a save, or if a custom business rule fails its validation check, the entire transaction rolls back cleanly.

Essentially, the platform puts the user in full control of data lifecycles and event triggers within the safety net of ACID transactions.

Performance at Scale

Handling Big Data

To smoothly handle massive volumes of data, SimpleOne implements:

• Pagination;
• Lazy loading.

Multi-Level Caching

The system does not just rely on a single caching layer. SimpleOne uses a multi-tiered approach:

• Server-side caching via Redis: This is the primary cache layer for serving up frequently requested data;
• In-memory caches: Both the backend and frontend use in-memory RAM caching to drastically reduce data access latency.

Migration and Versioning

Version Control System (VCS)

SimpleOne features a built-in VCS (Version Control System) module specifically designed to handle platform configurations.

This makes promoting changes across environments (like pushing a new workflow from Dev, to Test, to Production) incredibly easy. These configurations are versioned as packages and applied directly to the target instance.

During a migration, the VCS engine automatically flags:

• Collisions (merge conflicts);
• Warnings;
• Skips.

The VCS strictly tracks metadata and configurations — things like tables, columns, business rules, and UI elements that dictate how a specific instance behaves.

Quick Import

For transactional data that doesn't belong in version control (like user profiles or live tickets), a Quick Import mechanism is available. It relies on JSON payloads, allowing for easy export of records from one server and ingestion into another.

This approach is suitable for moving transactional user data that falls outside the scope of the platform’s configuration metadata.

Logging and Audit Trails

SimpleOne maintains a dedicated sys_log table, acting as the central nervous system for all changes. If auditing is enabled on a specific table, every CRUD operation performed by a user is permanently logged.

Configuration records are versioned automatically, meaning the system stores the entire historical timeline of a record for its whole lifespan. This means you can track the complete history of changes for any configuration.

The platform also features a real-time activity stream. When auditing is active, admins can see exactly what any given user has been doing — whether they were creating, updating, or deleting records.

Extensibility and Customization

No-code, Low-code, and Pro-code

SimpleOne offers three distinct levels of system customization to meet any business requirement:

• No-code Configuration: Business users can tweak standard out-of-the-box apps (ITSM, ITAM, SDLC, HRMS, B2B CRM) via a visual interface. With just a few clicks, they can modify forms, add new fields and statuses, and build approval workflows. This approach lets you get core automation off the ground quickly while gradually expanding the system’s capabilities;
• Low-code Development: When out-of-the-box isn't enough, administrators and systems analysts can use visual builders to map out complex business logic. They can hook into external APIs via pre-built connectors, set up complex data processing rules, and automate multi-step scenarios using simple scripts. The platform supports parallel development environments and the creation of highly scalable, repeatable business apps. Low-code speeds up development without sacrificing the flexibility of the solution;
• Pro-code Capabilities: For truly unique or non-standard tasks, developers have full access to write raw JavaScript executed by the V8 engine. This allows for building highly customized UI components, exposing new platform API endpoints, and writing heavy-duty server-side logic.

External Library Imports

SimpleOne features an "include scripts" mechanism that lets users bring in external JavaScript libraries. You can simply copy the source code of a library, package it as an included script, and add it to either your client-side or server-side logic.

Common use cases for this include:

• PDF Generators: Client-side libraries for creating PDF files;
• Data Visualization: Tools for drawing and rendering complex data visualizations.

If the native API doesn't have the exact function needed, the platform allows for the integration of open-source tools that do.

UI Customization

SimpleOne gives total freedom over the user interface. It is possible to create and configure:

• Custom buttons;
• Dynamic views and forms;
• Scriptable related lists.

These components are highly configurable and can be placed anywhere on the interface.

Additionally, developers can inject raw HTML and apply custom CSS within client scripts to ensure the UI aligns perfectly with the organization’s design system.

Widgets

Widgets in SimpleOne are full-fledged, reusable UI components built via Pro-code.

For any widget, the following can be defined:

• Custom HTML structure;
• CSS styling;
• JavaScript logic;
• Script-driven related lists.

Once built, these widgets can be embedded anywhere — from the agent's backend workspace to the employee self-service portal.

Integrations

REST API: This is a primary method of integration in SimpleOne. The platform allows you to create REST API requests to seamlessly interact with external systems.

Message Brokers

While SimpleOne uses Kafka and RabbitMQ internally, clients don't interact with these internal clusters directly for security and stability reasons. Instead, all interaction happens securely via endpoints and server-side scripts.

The platform does, however, provide server-side classes for integrating with your own external RabbitMQ setup:

• ExternalRabbitMQConsumer — for reading messages.
• ExternalRabbitMQProducer — for publishing messages.

By providing the host, port, and credentials, SimpleOne can seamlessly publish and consume messages from an external broker.

Out-of-the-Box Connectors

The platform comes with pre-built connectors that the SimpleOne team regularly updates to meet various client needs. Beyond that, any customer or partner has the freedom to build their own connectors and publish them on the Marketplace.

File Storage

The primary file storage engine is the S3-compatible MinIO. When a user uploads a file to SimpleOne, it is saved as an attachment and simultaneously pushed to the S3 bucket. MinIO then returns a secure URL for downloading.

If there is a need to interact with external, third-party file storage, the SimpleAttachment class in the scripting API can be used. This makes it trivial to, for example, fetch a file via a public URL and securely ingest it into the SimpleOne database as an attachment.

Security

Authentication and Authorization

SimpleOne supports standard enterprise authentication protocols:

• LDAP;
• Active Directory;
• OAuth2;
• SAML.

Access Control

SimpleOne enforces a hybrid access model combining Role-Based Access Control (RBAC) and Attribute-Based Access Control (ABAC). The platform comes with several base roles out-of-the-box:

• Security Admin;
• System Admin;
• Managers;
• Auditor (a strictly read-only role with admin-level visibility);
• Plus various modular roles specific to the apps.

Naturally, roles and permissions can be infinitely customized.

The security layer is enforced by strict Access Control Lists (ACLs) that operate with granular precision — right down to the individual field level. The platform defaults to a permissive model unless an ACL rule explicitly denies an action. Beyond static roles, the platform supports dynamic, context-aware access control. Permissions can shift in real-time based on user attributes, the specific record being viewed, or the current state of a workflow.

For troubleshooting and auditing, admins have access to an "impersonation" mode, allowing them to view the system through the exact permissions lens of a specific user. Every action taken while impersonating is strictly logged by the system.

Data Protection

Injection Protection

The platform implements strict measures to prevent SQL injections and other types of attacks. The architecture is specifically designed to eliminate injection vulnerabilities at the core level.

Penetration Testing

The SimpleOne platform undergoes regular penetration testing conducted by independent, third-party security firms.

Performance and DevOps

Background Processing

SimpleOne features built-in schedulers that handle regular background tasks:

• Parsing incoming emails;
• Log archival;
• Attachment indexing;
• Scheduled system scripts;
• Various other system operations.

System administrators and developers can easily configure custom background jobs:

• Scheduled Scripts: Code that executes at specific intervals;
• Delayed Tasks: Scripts queued to run after a specific timeout;
• Events: Asynchronous tasks triggered by system events and processed via message queues.

Business rules can also be tied directly to background tasks, allowing the scheduler to seamlessly handle both native and heavily customized background processing.

Testing

For automated End-to-End (E2E) testing, QA teams rely on Playwright.

When it comes to load testing, k6 is used, having been heavily customized for the platform's ecosystem:

• Custom Client: A custom k6 client was engineered specifically for SimpleOne’s architecture, enabling accurate testing of heavily customized, client-specific scenarios;
• k6 Wrapper: A wrapper was built that streamlines writing load tests, making the developer experience feel as intuitive as writing automated functional tests;
• Pre-filled Request Templates: All common platform API calls and payloads are pre-documented as templates. When QA engineers write new load tests, they simply pull from these templates, dramatically speeding up test creation.

The development team invested heavily in this custom load-testing infrastructure. Consequently, there is concrete, empirical proof that the system scales smoothly and recovers rapidly from traffic spikes — an absolute requirement for enterprise production environments.

Conclusion: Why Developers Choose SimpleOne

The SimpleOne Low-code and GenAI platform hits a rare architectural sweet spot. By combining a monolithic PHP core with high-performance microservices written in Golang and Node.js, the platform delivers the rock-solid stability of a monolith with the dynamic scalability of microservices.

SimpleOne is a platform that offers intuitive visual tools for business analysts (Low-code) while providing full access for engineers to write complex JavaScript (Pro-code). This allows for the resolution of problems of any complexity without the need to switch to an entirely different tech stack.

Through multi-level caching, asynchronous event processing, and optimized database routing, the system stands exceptionally resilient under massive enterprise loads.

SimpleOne is constantly evolving, guided by customer feedback and the latest tech trends. At the same time, it remains committed to the rock-solid stability and reliability of its core functionality.