Sl NetSolutions Logo

Domino API-Engine · Automation · Integration · Replication

Domino API-Engine

The Domino API-Engine by SL Net-Solutions is a powerful automation and integration platform for HCL Domino. It was developed to execute recurring processes, data imports, exports, synchronizations, replication scenarios and complex interfaces reliably and with high performance.

It focuses on tasks that are difficult, slow or hard to maintain using standard tools or plain LotusScript alone: large data volumes, complex business logic, mature Domino data structures, external systems and high requirements for traceability, stability and data quality.

The Engine can operate time- or event-driven and can process Domino databases as well as external data sources, file systems, SQL databases, web interfaces and structured exchange formats.

More than import and export

Controlled processing of Domino data

The API-Engine is not just a tool for simple data transfer. It can read, modify, create, synchronize and replicate Domino documents in a controlled way — even when the databases involved are not classic Domino replicas of each other.

This makes it possible to implement scenarios that would not be possible with standard Domino replication, or only with significant limitations.

The Engine is especially useful where Domino systems have grown over many years and need to be integrated, extended or migrated without losing control over data structures, local fields, links and business logic.

Typical tasks

  • Selective replication between Domino databases
  • Replication based on Notes-compatible selection formulas
  • Synchronization between databases with different Replica IDs
  • Localization of document, view and database links
  • Preserving or excluding specific fields during replication
  • Document-level transformation during transfer
  • Creation, modification and removal of fields in target documents
  • Error statistics and traceable result logging

Selective Domino replication

Replication beyond standard Domino replication

A key capability of the Engine is controlled replication between Domino databases — even if they do not share the same Replica ID.

Replication can be restricted by access rights, note classes and Notes-compatible selection formulas. In addition, field exceptions can be defined so that certain local fields remain protected in the target database.

This is useful when two databases contain similar or related documents, but local technical fields, status fields or site-specific information must not be overwritten.

Formula-based selection

Documents can be selected using Notes-compatible selection formulas, allowing precise control over what is replicated.

Field exceptions

Specific fields can be preserved in one database even when documents are synchronized with another database.

Different Replica IDs

Databases do not have to be classic Domino replicas. The Engine can synchronize related databases with different Replica IDs.

High control over the replication process

For replication and transformation runs, the Engine returns detailed result values, for example:

  • Number of updated documents
  • Number of newly created documents
  • Number of deleted documents
  • Separate statistics for each database
  • Optional error statistics
  • Errors during update, create, delete or transformation operations

This means that automated processes are not only executable, but also controllable, measurable and auditable.

Especially for productive background processes, migrations or business-critical data flows, this traceability is essential.

Selective Domino replication with the API-Engine Two Domino databases with different Replica IDs are synchronized through the API-Engine using formulas, field exceptions, link localization and detailed result statistics. DB 1 Replica ID A DB 2 Replica ID B API-ENGINE controlled replication Selection Formula replicate selected notes Field Exceptions preserve local fields Link Localization Doc · View · DB links Result Statistics update · create · delete Replication without shared Replica ID controlled, selective, traceable and measurable

Push-and-Replace

Replication with transformation

With Push-and-Replace logic, documents are not only transferred, but can also be transformed during the transfer process.

The Engine can search list fields for keys, extract corresponding values from related fields and write them into defined target fields. If a key is not found, default values or default fields can be used. Technical helper fields can then be removed automatically.

This enables complex field transformations directly inside the replication process.

Typical use cases

  • Converting old field structures into new field models
  • Migrating list values into normalized target fields
  • Deriving new fields from key/value structures
  • Cleaning up technical helper fields after transfer
  • Controlled data transfer with fallback values
  • Field-level adaptation during database migration

Extensible by design

Custom functions, data types and interfaces

The Domino API-Engine is designed to be extensible. Additional interfaces and processing logic can be integrated into the Engine through its own extension API.

Technically, this is done by adding new Engine functions and data types. These extensions can then be used directly within Engine scripts, in a similar way to built-in @Functions.

This makes it possible to connect specialized systems, proprietary data sources or customer-specific business logic without changing the basic architecture of the Engine.

What this means in practice

  • New interfaces can be added as Engine-level functions
  • Custom data types can represent external or specialized structures
  • External systems can be integrated without hard-coding one-off logic
  • Project-specific extensions remain reusable and maintainable
  • The Engine can grow with existing Domino environments and new requirements
@CustomFunction(…)
@ImportFromExternalSystem(…)
@TransformSpecialDataType(…)
@WriteToDomino(…)

Technical approach

A stable runtime environment, not just a collection of scripts

The API-Engine is not designed as a loose collection of individual scripts, but as a stable runtime environment for recurring, traceable and controllable processes.

It uses its own processing model, specifically designed for large data volumes and Domino-specific requirements. Data can be prepared, buffered, transformed and then written to Domino databases in a controlled way.

Especially with large NSF databases, high document counts, complex field structures, MIME content, attachments or replication scenarios, this approach is significantly more powerful and easier to control than classic single-document processing using LotusScript agents.

Capabilities

Core features of the Domino API-Engine

Time- and event-driven processing

Processes can be executed on schedule, repeatedly or triggered by specific events.

High-speed document processing

Optimized processing of large data sets, even in extensive NSF databases.

Own memory and document model

Data can be prepared, transformed and written to Domino databases in a controlled way.

Selective Domino replication

Replication can be controlled by formulas, rights, note classes and custom parameters.

Replication without shared Replica ID

Databases do not have to be classic Domino replicas of each other.

Link localization

Document, view and database links can be adapted for the respective target database.

Field exceptions and field protection

Specific fields can be preserved per database and protected from being overwritten.

Transformation during transfer

Fields can be created, replaced, derived or removed during replication.

Selection formula support

Notes-compatible selection formulas allow precise control over processed documents.

Note class support

Processing can be restricted to documents, design elements, views, forms, ACL notes and more.

Error and result statistics

Update, create, delete and transformation operations can be evaluated separately.

Extensible Engine API

Custom functions, data types and interfaces can be added through the Engine extension API.

Data sources and target systems

Integration with Domino and external systems

Depending on the project, the Engine can integrate various systems, formats and data sources. This makes it suitable for migration, synchronization, productive background processes and custom interfaces.

  • HCL Domino / Notes databases
  • SQL databases
  • REST or HTTP-based interfaces
  • CSV, XML and other structured files
  • MIME and mail data
  • EDIFACT
  • ZUGFeRD and electronic invoice formats
  • File systems and exchange directories
  • Custom business applications

Typical situations

“This Domino database contains large volumes of historical data that need to be processed regularly.”
“An old interface still works, but is barely documented and difficult to maintain.”
“Data must be synchronized consistently between Domino and a SQL or web system.”
“A LotusScript agent has become too slow or unstable for the data volume.”
“Two databases need to be synchronized although they are not replicas of each other.”
“Data must be transformed, cleaned up or moved into new field structures during transfer.”

Business value

Robust solutions for real Domino environments

With the API-Engine, existing Domino infrastructures can be extended in a targeted way without prematurely replacing systems that still work and remain business-critical.

Data remains usable, processes become more stable, interfaces become more traceable and large data volumes become easier to control.

The result is a robust, maintainable and high-performance solution for real Domino landscapes — especially where standard software is not enough.