Nexus Application Engine Platform
Smart software development: carrier grade, tested in production in the last 5 years, handling thousands of messages per second
                                    Model based
                                
                                
                                    Same visual model shared during design and runtime, between all actors (project team members and stakeholders). This is used
                                    to improve communication, to generate tests, to overlay observability and tracing ...
                                
                            
                                
                                    Domain specific
                                
                                
                                    Use a customizable domain specific language via drag-n-drop; every
                                    customer may defined its own domain language to bridge the semantic gap between stakeholders. We provide out of the box DSL elements for
                                    telecomunication industry, for system integration tasks, for common protocols interactions.
                                
                            
                                    Event driven
                                
                                
                                    Non blocking, reactive architecture that scales horizontally and supports very high number of concurrent sessions with low
                                    latency for each message.
                                
                            
                                    Platform
                                
                                
                                    It provides an advanced modelling environment that enables the user to focus on the domain problem and data flow/process flow/logic flow while
                                    it takes care of incidental complexity, like parallelism, synchronization, timers, scalability, overload, high availability, event sequences, retries,
                                    versioning, test generation and simulation.
                                
                            Architecture: event driven, non-blocking, high performance
                                Powerful creation environment, web based
                                
                                Advanced management and model analysis and validation module
                                
                                Real time execution environment
                                
                                Asynchronous protocol gateways that translates events to/from environment
                            
User interface screenshots
Product goals: efficient software development
One model for all
                                                Change the model and runtime changes automatically, tests are generated automatically and
                                                operations dashboard receives new information.
                                            
                                        Short and fast iterations
                                                It enables quick prototyping, versioning, validation. It reduces time to productization by shortening all phases.
                                            
                                        Budget efficient
                                                It reduces costs by enabling the grow of development team with domain experts, making changes or improvements to the model without intermediation.
                                            
                                        Partner with your customer
                                                Instead of writing specification and run lengthy analysis, customers can work on defining visually the shared model; the changes are immediately tested and validated.
                                            
                                        Features
Smart software development platform
Performance
                                        Nexus AEP is build from ground up with performance in mind; this means: five 9s availability, unlimited number of concurrent session (horizontal scalability), low latency (<20ms).
                                    
                                Protocols & Integrations
                                        Protocols:SS7 Application Part, SIP, Diameter, Radius, SMPP, ENUM/DNS, LDAP, HTTP 1.0/1.1/2.0, JMS, JDBC-compliant, SMTP
                                        
Integrations:RDBMS via JDBC, NATS, NSQ, Redis, Tibco Rendezvous, Active Directory, Apache MQ,
                                Integrations:RDBMS via JDBC, NATS, NSQ, Redis, Tibco Rendezvous, Active Directory, Apache MQ,
Deployment
                                        We support bare metal deployment, virtualized with hypervisor, Kubernetes/Docker containers or public cloud environments. The most used options with our
                                        customers are virtualized via VMWare, OpenStack and KVM or public clouds. The most common form of shipment is tar balls with Ansible roles (we tend to avoid rpm or deb packages
                                        because they require root privileges); even the Docker images are built progressively using Ansible provisioning.
                                    
                                Technologies
                                        90% of our platform is build on top of JVM, using either Java or Clojure programming languages. We are using extensively Redis as a communication bus / message queue
                                        (due to small latency and easy administration) while for fronted we use plain Javascript and/or VueJS.
                                        
In order to provide advanced processing directly in model specification, or for prototyping, we allow the use of TypeScript or Clojure embedded in the model definition.
                                In order to provide advanced processing directly in model specification, or for prototyping, we allow the use of TypeScript or Clojure embedded in the model definition.
Components & Extensibility
                                        There are three main components that we provide: (1) admin UI and designer, (2) real time execution environment and (3) reactive I/O gateways for interworking with the
                                        environment.
                                        
There are two main directions for extensibility: providing a domain language in the form of model building blocks and providing reactive I/O gateways. Both types can be provided without involvement from Quasar, from us.
                                There are two main directions for extensibility: providing a domain language in the form of model building blocks and providing reactive I/O gateways. Both types can be provided without involvement from Quasar, from us.
Management & Observability
                                        Due to versatility of the platform, and because we enable non-technical people to contribute to development, we pay special attention to observability,
                                        tracing, versioning, access management and audit. We map alerts and metrics to the application model, we trace live messages/sessions that can be replayed
                                        later and we provide sophisticated, attribute based access control with audit features.