SABRE is based on the JAVA platform and hence can be easily deployed across different operating systems. The components inside SABRE have been designed and built in such a way that an application running on SABRE on a particular operating system can be seamlessly moved to another operating system without loss or change in functionality. *

SABRE handles every independent business flow or transaction in a different programming context. This ensures that all the data pertaining to a particular transaction or business flow is kept secure from accidental change / damage from other concurrent processes, thereby ensuring that data correctness is maintained.

The remarkable feature of Context Switching and Context Injection helps to take transaction processing to a new level where a transaction can be moved into an altogether different business flow based on some business conditions. This opens a host of possibilities of designing complex business flows, yet keeping the programming and implementation simple.

SABRE has been built keeping in mind the requirements of enterprise applications for high performance. A number of optimizations have been made in the way data is accessed over disk or network IO. The Object Factory which is an integral component of SABRE, ensures that the overhead of object creation is considerably reduced, thereby saving precious CPU time and increasing performance. Transparent asynchronous processing behaviour ensures that wait times are drastically reduced and the CPU is used more efficiently. Thread safe and Symmetric Multiprocessor safe implementations ensure that a large number of transactions can be processed concurrently resulting in higher throughput.

The transaction processing model used in SABRE ensures that a failure, error or uncaught exception does not result in any side-effects to the system as a whole or to other transactions that are being processed in the system. The system also ensures that in case of errors during processing, if any of the threads die, they are restored so that the transaction processing capacity of the system does not get affected. Even the input processors and database connection manager ensure that the configured handling capacity is always maintained. Coupled with the context based approach, SABRE ensures transaction correctness, system availability and robustness.

SABRE has a very small memory footprint. The internal components of SABRE, by themselves do not require a large amount of system memory. They are also very judicious about CPU utilization. This results in a very efficient engine, which helps the software designer or architect to correctly judge the system requirements based on the actual application, and prevents the requirement of extra heavy duty hardware just for the framework.

SABRE religiously sticks to the best practices of Object Oriented Programming concepts and Design Patterns. This results in a system that has a high level of cohesion, but is loosely enough coupled to allow flexibility and extensibility of the components. Most of the required functionality provided by the in-built components can be used as-is, but whenever any custom changes are required, the software developer can very easily and conveniently modify the system to suit his requirements.

All the rules that are created as a part of the system are also reusable, which means that as long as the rule performs its function, it can be used anywhere in the rule chains, and that too for any number of instances. It follows a simple motto: code once, reuse many times.

SABRE can be run either in embedded mode or can be used as a container to run the required programs. In embedded mode, SABRE runs as a part of the application's JVM. The application program controls the lifecycle of SABRE. Embedded mode allows easy integration of SABRE into existing programs or even other frameworks and application servers like Tomcat, Websphere etc. Due to this adaptability, the process of adapting existing programs to SABRE becomes very smooth.

In container mode, SABRE acts like an application server. There is a single JVM which caters to SABRE which in-turn ensure the smooth functioning of the application(s) running within it.

Both these modes provide similar functionality, but for intensive applications where finer grained control is required over performance parameters like threading, concurrency, memory size etc., use of embedded mode is recommended.

SABRE has a database management agent which it very easy to integrate database functionality into programs. The database management agent literally takes away all the work required for connecting to databases and managing connections with the databases. The entire work of connecting to databases, maintaining connectivity, reconnecting on failures etc is reduced just to configuring the same. Not only that, SABRE allows you to connect to multiple heterogeneous databases simultaneously. Even switching from one database vendor to another becomes a matter of a few configuration changes, and requires no or very minimal code change.

The database management agent also adds in the features of maintaining connection pools of the required database connections. This reduces the overhead of creating database connections at runtime, thereby increasing performance. Not only connections, but the required query and update database statements are also pooled for increased performance. In case the connection to the database is lost, the database management agent also ensures that all connections are re-established along with all the pooled database statements.

These features provide a configure and forget system which makes the time to market for the application minimal.

Traceability is one of the biggest requirements where transactions are concerned. SABRE provides for tracing the results for the entire transaction through logs and event records. The event records can be configured to contain the required data from the transaction, so that it can be printed or logged at the end of the transaction. With useful data like error codes, result data, failure data, date and time etc, it is possible to find out the result of transactions. The entire process flow of the application is logged by SABRE with varying levels of detail so that any errors or issues can be traced by studying the logs.