New approaches, tools and frameworks made it possible to create more complex applications, while flexibly controlling development at each stage, adapting to new requirements and circumstances.

They provide opportunities for collaborative work, uniting several different teams into a single workspace, speeding up development and making it transparent and understandable for management
Application creation stages
  • Collection and analysis of business requirements
  • Estimations, risk assessment
  • Team management, onboarding, mentoring
  • Application architecture development
  • Main business logic development
  • Quality assurance, code analysis
  • Deployment and monitoring
  • Documentation
After market analysis, collection of business requirements, preliminary time assessment, the development stage begins. The better the team is familiar with development tools, the faster it will release the MVP, the faster your product will be able to enter the market.

However, before the development of main business logic starts, you need to create a foundation, a skeleton of the application, select an architecture, and develop the necessary components required in any application.

Depending on the complexity of the application, this stage can take from several weeks to several months. Miscalculations made at this stage may lead to poor code quality, rewriting of a significant part of the code, wasted time, and inability to implement basic business logic.
Depending on the complexity of the application, architecture development stage can take from several weeks to several months. Miscalculations made at this stage may lead to poor code quality, rewriting of a significant part of the code, wasted time, and inability to implement basic business logic.

The application skeleton stage is incredibly important, and the cost of failure is high, but what if you could use an already proven tool, based on the latest and well-known technologies, that provides a ready-made foundation and architecture for the application, extends the core functionality through plugins?

Rengine is a low-level, infrastructural framework that serves as the skeleton for creating complex and multi-functional projects. It is rather flexible, expandable, and may be modified according to the project needs.

​The main idea of the framework is to significantly reduce the complexity and development time for common case scenarios by simplifying frequently used operations and creating ready-to-use modules.​
Features and benefits
  • Reduce time to market
  • Reduce code complexity and development time
  • Reduce infrastructure costs
  • Standardized, flexible and extensible architecture
  • Based on popular and well-known technologies
  • Ready-to-use security and data management solutions
  • Reuse framework modules in multiple projects
  • Track and analyze the history of all user actions
  • Built-in multilingual support for data objects
  • Various database management systems support
  • Simplified deployment and testing
Use cases
Each application, regardless of the main business logic, has some common functionality that can be moved into separate modules, with simplified access, but with expanded customization options, if necessary, which cover different use cases.
  • Architecture
  • Data management
  • Chronicles
  • Security subsystem
  • Localization
  • Storage
  • Seeding
  • Erasure
  • Logging
  • Configuration
  • Quality assuarance
The main idea of the framework architecture is to divide the functionality into independent layers and handlers. The framework uses the mediator architectural principle. Handler is a small piece of business logic, completely independent of other logic, thus allows you to change it without the need to make changes to other components of the project. A handler should be responsible for one certain task. A handler must comply with SOLID principles.

Each layer is strictly specialized and performs work in a specific area. Functionality from one level should not in any way affect the functionality of another level. It is not allowed to directly access internal resources of another level. Such architecture allows to create scalable and fault-tolerant applications. Handlers are building bricks from which you can assemble several micro-services or one major service, depending on project needs.

The absence of dependencies between handlers and layers makes it easy to make changes to the business logic of the application. In addition, this approach puts the developer within certain boundaries, which is quite difficult to go beyond accidentally or intentionally, thereby reducing the requirements for the developer’s experience and the likelihood of mistakes. ​
In the modern world, data security comes first. A hack or leak can cause serious reputational damage and financial losses. It is very important to use proven algorithms and techniques to ensure the reliability and stability of the application. The framework provides a completely ready-to-use security subsystem containing the following features:
  • User management – loading, saving, validation of users and related data.
  • Role management – loading, saving, validation of roles.
  • Permissions and restrictions management – loading, saving, validation of user actions.
  • Authentication - using Auth0 and Azure Active Directory B2C, that meet all modern security requirements and allow multi-factor authentication. It is also possible to integrate other identity providers, including standalone.
  • Authorization – each user action will be checked considering the roles assigned to it, only available data will be loaded.
Data management
Working with business objects is an integral part of any application - creation, loading, saving, validation, transformation, serialization, etc. The framework standardizes and significantly simplifies these operations, saving development time:
  • Business objects creation and initialization with cloning capabilities.
  • Business objects loading from a data storage with filtering, sorting, paging capabilities. It allows to load only necessary object properties, thus increasing performance and reducing the payload size. It simplifies the loading of child records with all types of relations (one to one, one to may, many to many).
  • Business objects saving to a data storage with validation. It allows to save only necessary object properties, thus increasing performance and reducing the payload size. It simplifies the saving and validation of child records with all types of relations (one to one, one to may, many to many). It allows soft delete with deferred erasure.
  • Reach validation capabilities. FluentValidation, Net validation attributes and custom validations are supported. Validation messages may be attached to each business object property, thus making validations user friendly. It is also possible to compare new and previous version of each business object.
Usually, an application stores and processes a huge amount of data, for the reliable storage of which database management systems are used. The Rengine framework supports Microsoft SQL Server and PostgreSql database management systems.

It is also possible to integrate additional database management systems if needed, including non-SQL databases. The framework uses Entity Framework Core, Linq2Db and Automapper under the hood, to reduce code complexity and get rid of writing unnecessary SQL code. But it doesn't limit a developer - custom SQL code or SQL procedures may be added if necessary. The framework supports a multi-layer structure that allows to save data in multiple storages and caches.
In complex information systems, it is often necessary to maintain the history of changes for each record. Sometimes it is required by law, sometimes it is necessary to enhance security, sometimes it can be useful for restoring older versions of data. The framework may track data modifications and store the history of those modifications and their authors. Framework may save changes metadata only in main database or the entire changes history in ElasticSearch.
Each application contains data that should be present already at the first start. In addition, this data may be updated periodically. To provide these opportunities, the framework provides a mechanism called Seed. This functionality allows to read a file and populate the data into the data storage. It will take into consideration file modification history and won't update unmodified records.

Seed may be used to update the data on production environment or populate test data on test and development environments, which will be useful for QA and development purposes. Seed data is usually stored in excel or csv files, but other formats and even external services may be added if needed.
Sometimes these types of data take up too much space and it is needed to delete something. When a record is deleted, it is only marked as deleted, but not erased from the database. To erase records completely, the framework has a mechanism called Erasure. It has flexible settings and allows to completely erase outdated data from the main database as well as from chronicles.
The modern application must support several languages and formats for text data, dates, numbers, validation and error messages, notifications, etc. The framework provides special tools for saving, loading and displaying localized data.
The framework can be used for applications of completely different functionality and purpose. It contains general, but highly customizable functionality. Each handler contains different kinds of configurations that can change its behavior.

The framework uses standard Net tools to read the configuration. The source of parameters can be environment variables, configuration files, encrypted parameters, discovery tools, etc.
In an application, thousands of different actions and events can occur every second that need to be stored, monitored, and possibly reacted in a certain way. The framework provides rich functionality for tracking and responding to such actions and events, it is also compatible with various monitoring and log storage systems.
Quality assuarance
Dividing the functionality into separate independent handlers allows you to test them separately, which greatly simplifies the creation and execution of tests of any kind: unit tests, integration tests, load tests, security tests.

The framework provides tools for creating and storing test data, which allows you to quickly create test environments, run tests and free up resources, thereby saving significant money on infrastructure.

The framework uses tools to analyze code quality, they are free and open source. Similar tools can be used for the application.
Need more information?
The framework contains a lot of additional features. We may schedule an online meeting where we will explain in detail all the benefits of the Rengine framework along with code examples.
Request a demo