Platform – what is it?

  • Application constructor

  • Shorter time-to-market, faster implementation process

  • Customers are less dependent from software provider and their own IT.  No qualified programmers or software product expertise required to operate and develop the system.  Legal department staff would be able to enhance, adapt and tune the solution themselves

  • The solution might be integrated into customer’s existing IT environment

  • The solution might be adapted or modified at any time, on the go, when necessary – no need to re-launch a costly software development and implementation project.  Customers may experiment with fine-tuning business processes, modify and reconfigure them on their own. Our solution is less dependent on business-process methodology, which happens to be a usual corporate bottle-neck in terms of time and resources


Technology stack

At the moment we support only Postgres database but the platform does not depend on the type of database. The data is stored in such a way that in the future we can switch to any relational and also NoSQL databases without any source code refactoring of already created applications. We only need to implement another database hub in Dolmen platform


Use cases

  • Full-stack solution for any business

    • Own database + any external sources

    • Business processes, reports

    • Notifications (e-mail, messengers)

    • Thin client

  • Integration hub​

    • Collecting various data from external systems​

    • Consolidating data

    • Providing results as API for other systems or clients

  • Single entry point​

    • Integration with various external systems​

    • Displaying consolidated data

    • Managing data using Dolmen as a single entry point

  • Any combination of use-cases

Key features

  • High performance

  • Extremely quick development

  • Open code for applications based on Dolmen platform

  • Very short time to market

  • Transparent architecture

  • Simple deploy and upgrade for platform and applications

  • Simple functionality customization

  • Declarative web interface with customization

Technical requirement

  • Dolmen server

    • OS Windows > 7 or Linux

    • Memory: > 4GB free

    • Processor: modern (installed on middle-end / high-end desktops)

    • Disk: 1GB

    • Backup: not needed (stateless)

  • Database server​

    • OS Windows > 7 or Linux​

    • DB: PostgreSQL recommended version 9.6 (supported any > 9)

    • Memory: > 3GB free, recommended > 12GB

    • Processor: modern (installed on middle-end / high-end desktops)

    • Disk: > 50GB, SSD recommended

    • Backup: regular

  • Web server​

    • OS Windows > 7 or Linux​

    • Memory: 1GB free memory

    • Processor: high performance not needed

    • Disk: 1GB

    • Backup: not needed (except Certificate Authority key)

    • May be installed on Dolmen server

  • Network​

    • Dolmen server to Database server: high speed low latency network​

    • Web server to Dolmen server: > 10 Mbits

    • Web browser to Dolmen server: 100 Mbits recommended

    • Web browser: Google Chrome recommended (well tested)

Development notes

  • Dolmen tables are objects and may contain other objects as hierarchical data

  • For all described tables Dolmen system creates java/Kotlin classes with corresponding properties

  • Table may be “abstract” – not stored in Dolmen database but created on the fly. For example, the following may be included in the table data

    • Data from external sources and services​

    • Combined data from local or/and external sources

    • Any specific data as files and so on

  • We have already predefined Dolmen interfaces to some external sources (for example SAP, 1C etc), where in the table description you just point to corresponding external object and Dolmen system creates all integration automatically​

  • Dolmen system does not map described tables into relational database as plain tables, but rather packs each record and stores it as a packed structure in a single field. The only exception is made for indexed fields, as relational database cannot index a table in another way

  • Dolmen system has almost schema-less database structure and almost zero impact on database schema changes

  • Dolmen system does not need any alter scripts. The DB structure is changed automatically, hence simple installation and upgrade

  • The only DB features used are transactions and indexes, so NoSQL databases, as well as relational databases may be used (to be supported soon for big data projects)

For example file test_main.json contains table description, where we can see several types of fields

  • f_string – string field, usage “name” means this field value will be a label for the record

  • f_integer – integer field with default value = 1

  • f_enum – status field with two values “v1” (label “Label 1”, default value) and “v2” (label “Label 2”)

  • f_datetime, f_datetimemillis, f_plaindate – different date fields

  • f_ref_main – reference to test_main table (to the same table). All references by id, refDelete option (constraint) instructs Dolmen system what to do with source record when linked (target) record is going to be deleted

  • f_text – text field

  • f_bool – boolean field

These are sample language constructions which allow you to describe your own logic – java/kotlin code for

  • Buttons in the UI

  • External communications

  • Abstract tables

  • Other needs

All functions declared in a Dolmen module class are API functions.  After module installation they may be called from web interface, using standard API or from test web console

Web interface

  • UI is declarative

    • developer just configures a screen and does nothing with web page layout and writes no java script code​

  • UI is extensible​

    • front developer may add new custom types of “part” presentation (Angular component development) and then Dolmen application developer may use these components in screen declaration​

  • UI layout is customizable​

    • front developer may change CSS layout for a Web site and customize the site according to end-user requirements​

  • UI is based on rich client technology (Angular framework from Google)​

    • no high load on web server. Angular engine works on client web browser, so no bottleneck on web server​

  • UI screens are stored in Dolmen database in JSON format​

Web interface for each module consists of a number of screens. Every screen is a set of Parts, where Part is a widget – table, form, graph, tab control, tree control, picture gallery, rich text editor, etc. Parts layout based on screen grid is defined in the screen.

Each Part has to be referenced to a data source, where data source is a set of data obtained from Dolmen server. Usually data source is a table having been defined previously, though, sometimes it may be an API function, e.g. for graph Parts. Several Parts my be linked to one data source and show the same data differently

We use special Dolmen screens as editor for dolmen screens :)

Some screen samples from some applications based on Dolmen

We also have roles and grants in the box

Each screen item may be localized to the specific language using auto generated localization files


In general, to start writing code in Dolmen, developer should learn the following

  • Basic level of Kotlin (or Java) language

  • How to declare Dolmen objects (tables)

  • Operations with Dolmen data

    • Select by ID​

    • Select by where condition

    • Update

    • Delete

    • New

    • Iterators (cursors) to go over selection

  • How to work with Intelij IDEA framework (basic level)​

  • Dolmen screen concept

© 2020 Dolmen