Neutrinos Platform Analysis
BDD / TDD
Behavior Driven Development and Test Driven Development practices allow you to foster a quality driven delivery process in your teams. Although the requirements for creating the tests do not vary a lot, the approach allows teams to focus the creation of tests for the most critical use cases.
The BDDFramework component in Neutrinos Forge is an open source component that you can adapt to your own needs, but already provides an easy way to:
- Create test scenarios and steps that are conformant to the principles of Behavior Driven Development.
- Enable Test Driven Development – by defining scenarios and steps early in the app design stage and write the test code when the features have been implemented.
- Easily add scenarios and steps by dragging and dropping blocks (Scenario + Given / When / Then clauses).
- Having each test step is implemented in its own action, making sure that steps are sequential and occur in the same request.
- Enhance Test Maintenance – test outputs are identical to what is designed in the IDE, making it easy to pinpoint step failures and evaluate the code behind them.
- Support multiple tests in the same page and evaluating final stats (number of successful / failed tests).
The following video provides an overview of how the framework can be used to automate a test on a sample eCommerce application:
Functional, User Interface, Regression
For functional and regression testing of Neutrinos applications, we recommend using Selenium. Since Neutrinos applications are standard web applications, any strategy currently used to test traditional web apps can be applied. Neutrinos provides guidance and best practices on how to use Selenium to test Neutrinos applications.
In addition, in Neutrinos Forge, there is also Test Automator, a browser (Selenium-based) and unit (WebService-based) regression testing tool that can help teams get started.
How does Neutrinos enable team collaboration?
Apps developed with Neutrinos consist of modules, which makes team collaboration easy, even for development factories with a large number of developers. In a modular system, multiple developers can be working on a single app but because it is composed of modules, they are most likely to work in separate modules. However, if it is necessary, teams can collaborate in the same module.
With Neutrinos, developers create modular application architectures that enable organizations to isolate the areas where developers work. These “multi-module solutions” eliminate many developer or development lifecycle conflicts. Multiple developers can work in separate modules with the confidence that their work will not be affecting others. All versions of applications and modules are stored automatically in a central repository, every time they are published. Relevant application and module milestones can be tagged, version history – including who and when – can be checked and rollback to any prior version can be easily downloaded.
Multiple teams in large organizations
To enable multiple teams in large organizations to collaborate and to reduce the number of development cycle conflicts significantly, Neutrinos enables different developers to work in different modules at the same time with:
- Deployment plans
- Staging control
- Federated user management
- Operation audits
- Starter templates
With Neutrinos, developers create modular application architectures that enable organizations to isolate the areas where developers have to work to make a specific application change.
In addition, there are a number of components available to help teams keep their portfolio of applications healthy:
- OutDoc: Generates application documentation and basic architecture diagrams
- Discovery: Helps you assess your entire portfolio’s health
IT collaboration in a deployment plan
When multiple teams are working at the usual rapid delivery pace enabled by Neutrinos, all eager to push changes to production, sometimes you end up with daily deployment cycles with changes from several different teams.
A shared deployment plan can support these complex deployment scenarios by enabling teams to add their applications and synchronize, in a single operation, the deployment of their changes to another environment.
All deployment operations are governed by the permission levels. Any user with the appropriate privileges can add an application to a plan. Executing the plan, however, requires permissions for all applications in the plan.
Staging control for complex deployment scenarios
As a portfolio grows and the number of applications and modules increases, it is only natural to expect different development and operations lifecycles for applications and modules. If a portfolio has hundreds of applications and modules, it will require more specific control over which versions of the applications and modules are pushed to production. Moreover, perfect visibility of the impact and timeframe required for deployment is critical.
Neutrinos provides fine-grained control over deployment operations. Typically, teams will push an entire application version between environments with one click. But it is also possible to choose which individual modules to push. This enables someone to quickly push a small hotfix, instead of deploying the full app. In addition, deployment plans are validated to make sure that all dependencies are satisfied and apps are consistent.
Federated user management
Neutrinos enables each user to have one role in each team and that role automatically applies to all applications that belong to the team. Adding or removing users and applications to the team is easy.
To support a federated development model, where the central administrators ensure they remain in control while opening the door for each team admin to manage their own teams, there are the concepts of Team and Application Manager. Users with these privileges for an application can manage that application’s privileges for other users.
Similarly, if a user has that permission over a team, the user can add and remove other users to and from the team, without requiring an administrator.
Enterprises often keep information about events that occurred in their systems or networks to help system operators troubleshoot problems, track system usage, record the actions of users, and provide useful data for investigating malicious activity.
Neutrinos logs all activity that changes the state of infrastructure, including user management, role management, team management, infrastructure management, and application lifecycle operations. This logging is available for all top level objects, such as users, roles, teams, applications, environments, and infrastructure and helps organizations identify who did which operation, over which object, and when it was done.
Starter templates normalize and bootstrap apps
With the set of templates provided by Neutrinos, team members can create new applications that share the same look and set of widgets.They can also be bootstrapped with an initial set of service or API references that not only ensure the overall visual consistency of apps, but also guide them in complying to standard enterprise architecture.
Developers can also find and share templates in the Neutrinos Forge, getting help from and helping everyone in the Neutrinos Community.
More information about large team collaboration
Additional details about features that enable large team collaboration are available in this article.
Team collaboration in the same module
For developers working in the same module, Neutrinos offers everything that is needed to implement a continuous integration development cycle between developers:
- Compare and merge
- Resolve and detect conflicts
- Developer sandboxes
- Version control
- Tagging for deployment
Developers are able to manage versions, releases, deployments and all component dependencies for multiple staging environments from a centralized console. There is no need to install complex tools for configuration, build and version control, nor find the experts to set them up.
Teams can easily view which version is in each environment and can automatically deploy or rollback an application version with a single click:
Compare and merge
The development environment of Neutrinos enables developers who work in the same module to merge their work. By default, Neutrinos will automatically merge the differences, but the option is there for developers to compare and manually decide what gets merged before publishing.
This image illustrates a situation for comparing and merging work before publishing:
This is the situation. One developer opens version 4 of the module in his development environment and starts developing while a second developer does the same thing with version 4. Both publish their changes. At that point:
- Neutrinos determines the changes to be merged based on the version from where both started developing (version 4).
- The modified version is detected so the developer who publishes last can compare and merge.
- The developer compares and checks the changes to be merged.
- The developer merges and publishes.
This is what the visual merge looks like when developers are comparing two different versions:
When developers work in the same module and change the same elements, Neutrinos identifies any conflict and helps resolve it by offering a choice of which changes to merge and publish.
This image illustrates a conflict encountered in development.
In this situation, one developer has opened version 4 of the module in their development environment (1) and is developing while another developer is doing the same thing with version 4 in their development environment (2). The first developer then publishes the changes as version 4 but the second developer publishes their changes as version 5 (3). In this scenario:
- Neutrinos determines that there are changes to be merged between version 4 and version 5
- The second developer will be able to compare and merge and decide which conflicting changes to keep (4)
Here’s an example of a conflict that was detected:
Neutrinos provides developers with a private sandbox for their development activities. This makes it possible for several developers to work in the same development server without affecting one another’s work.
In a development server, all Neutrinos applications have a public area and a private area (sandbox). When a developer is working on a change to an Neutrinos application, he is able to deploy changes only to his private area during the develop-test cycle. When the functionality is stable and can be shared with the team, the developer can publish and merge his version of the application with the version in the public area.
The backbone of all these collaboration capabilities is the built-in version control engine of Neutrinos. From the time applications are first created, Neutrinos keeps all versions, components, and connectors stored in a central repository transparently whenever someone publishes an application. Users can navigate through versions, see when and who published them, download or roll back to a previous version. During development, this is done automatically, which saves time and work.
This is an example of the version history of a module. Notice it’s possible to download or rollback to any previous version with a single click:
Tagging for deployment
With Neutrinos, it is possible to take a snapshot of an application and its dependencies, tag it with a version, and then use it for deploying. In this example, the Vacations application has new functionality for submitting half-day vacations, so it is tagged and development continues.
Tagging an application is critical to ensure infrastructure stability and flexibility. Tagging is usually done when the application development is stable or a milestone is reached, allowing for the retrieval of that state of the application and its modules at any time.
Development teams can tag a version of their application each time they reach the end of a sprint. Then, they start a new sprint and continue developing their application. Meanwhile, tagged versions of the applications can be deployed to quality assurance without interrupting the continued development of the application.
Can I integrate Neutrinos with SVN, TFS or GitHub?
Yes. Neutrinos enables the management of different versions across different environments, according to development and staging pipelines and includes APIs for integrating with alternative configuration management systems.
Organizations often must comply with specific internal rules that require that all application code be kept in a specific system, such as Team Foundation Server, SVN, Rational Team Concert or GitHub. Neutrinos has the APIs to retrieve any committed version and the ability to detect programmatically when a new version has been published in any of a customer’s environments. Based on this information, it can easily create an integration into the existing source control system to ensure all application histories are properly tracked there.
Neutrinos includes version and source control out-of-the box. All versions of applications and modules are stored automatically in a central repository, every time they are published. Relevant application and module milestones can be tagged, version history – including who and when – can be checked and rollback to any prior version can be easily downloaded.
For more information about version and source control, see this article on team collaboration with Neutrinos.
Once you sign up, we are a young platform playing in the big league and while we constantly work to make our platform self-serviceable to the best extent, we also understand support is key. Besides building new components and modules every day, our teams also use the platform to build apps – for ourselves and for PoCs. The advantage of having teams work hands-on is that we feedback, question and support each other and this enables us to know what our customers’ teams need.
We’re building extensive knowledge-bases with tutorials and videos to learn from and our partner network is growing strong. We offer training to our partner and customer teams as needed with certifications. With all that in place, we are still proud that the platform is very intuitive and user-friendly. One of our own employees, Tukiso, is proof that Neutrinos is truly the easiest rapid application development platform.
Typically, journey for developers start with a free trial that opens up the platform, its features and the marketplace for a fortnight. Enterprises tend to start with a demo where our team provides a physical or a virtual walkthrough followed by creating demo accounts.
Learning is done during live projects and on-demand for enterprises. Our partner teams also receive training. Our developer community is also actively growing and will help fellow developers build enterprise-grade mobile, web and hybrid applications.
We saw the need for all applications to be mobile-ready and as a need, all of our modules and components to be responsive and mobile-ready. Our video library is being enriched everyday with tutorials to build different types of web applications and enabling with mobile readiness.
Some of our customers also have large teams with immediate needs to churn out applications. In such cases, we also have dedicated trainers who can assist customer teams get used to the platform.
Development on the platform is primarily visual. Every component of an application, be it the CMS, UI or third-party plug-ins, is brought into the design and development using visual pieces. Although access to the code is available to customize components and the overall app, the visual rich studio does the job seamlessly.
Required Proficiency Level
Neutrinos is a low code platform and anyone with little or no coding experience can build apps. It does help to have basic understanding of coding, but is not mandatory. With apps as the end-objective, anyone can design, develop and deploy apps in a matter of days to weeks depending on the experience level.
Anyone with a little bit of hands-on coding experience will pick up quicker and can start feeling comfortable on the platform in a couple of weeks. Developers with prior experience working on IDEs and low-code platforms will be able to comfortably work on the platform even faster. Non-tech users from other business functions may take a little over a few weeks to understand the basics of application architecture, development, testing and deployment. This is all assuming through self-learning practices. Should teams decide to opt for training, the learning time will be significantly reduced.
Do you need to hire Neutrinos experts?
The simple answer is no. Your in-house team is more than sufficient to learn and start building apps. Our training partners can also assist in getting your team proficient. We would be happy to discuss capabilities and proficiency that are best to look for while selecting team members.
To make it clear, Neutrinos is not a new technology skill that you/your team needs to master. It is a platform that simplifies app development with drag-drop-develop methodology. Both tech and non-tech users can leverage on the platform’s capabilities and deliver business applications. With that covered, the concept of learning basically means understanding where components are, how to go about designing, how to deploy on the cloud with a single click or deploying on-premise with basic system requirements.
By pre-building components using the different programming languages used to build any web and mobile application, Neutrinos enables teams to utilize templates and packages. The templates conform to enterprise standards and compliance needs and more often than not, function similar to near plug-and-play components and applications. Code customization is needed when UI changes or other functionality tailoring is required. Within a few days to weeks, you developers will be able to showcase significant increase in development time.
No Code and Low Code
Although, some features of the Neutrinos platform make it appear to be a no code platform. That is not Neutrinos’ single value proposition and we acknowledge and encourage teams to access and customize the code as and when needed. The platform will primarily help teams achieve the following.
Quick Delivery of Market-Ready Applications
With all of the underlying, redundant coding out of the way and testing, deployment and maintenance setups done on the platform, developers can focus just on building great applications.
Coding becomes purely visual and thus, developers can pitch in anytime to pick up task from a different team(s). The platforms’ components and modules maintain the same standard across the board and it eliminates anomalies.
Neutrinos for Developers:
Neutrinos is built for all and one of our key focus has been and will continue to be catering to developers. There are two ways individual developers and citizen developers (users with no coding experience at all) can benefit from our platform:
- By leveraging on pre-built components and modules and building applications that translate ideas into presentable, delivery-ready solutions
- By building and sharing components, modules and templates on the Neutrinos Store, our marketplace and monetize their skills
Enterprises with in-house teams can opt to get a free trial of the platform. The standard free trial period is 14 days, which can be extended on request.
The free trial account will provide an administrator account and 5 developer accounts. During the trial period, five android applications can be developed and deployed on the cloud.
Companies with multiple developers, advanced staging scenarios and multiple servers who want personalized support can request a 30-day enterprise subscription trial and, if approved, use it to see if Neutrinos is right for them.
Free Trial Support
For enterprise trial accounts, the Neutrinos Support team will assist in onboarding the organization admin. For developer trial accounts, an account will be created and credentials will be shared.
While on the trial period, users can contact Neutrinos Support for assistance.
Consulting and Concept Evaluation:
Prior to signing up for a licensed access, enterprises can request for a proof of concept to evaluate the platforms usefulness to their business. Neutrinos’ team will work with the customer’s team in delivering applications that cater to a current business need. During this process, compliance, integration capabilities, scalability, etc. also are demonstrated.
Application Development Services
Some businesses, might not have the need to have an in-house team setup or have plans to build a team in the longer term, but require apps nevertheless. In such cases, we evaluate requests and assist businesses in various capacities. The simplest way to begin engagement is with a proof of concept build and assisting with scale. Request a demo to understand how Neutrinos can address your business needs.
If your team needs training in utilizing the platform, please refer to the training methods segment or contact us.
Professional Services can support your adoption through a mix of enablement and delivery services.
We deliver you everything needed to jump-start a project, from baseline training to complete hand-holding during the requirements gathering stage.
The Project Kick-Start service provides side-by-side coaching and mentoring in technology and delivery methodology from experienced Neutrinos Success Team members. With guidance and hands-on work, your team can successfully deliver their first application using Neutrinos and get on a path to autonomy by watching and learning from our experts.
Project Co-Delivery combines a full co-delivery approach with peer-to-peer coaching. Together we create a customer-centric digital experience, using our code and architecture best practices. On top of that, we provide a precise estimation of a project scope to assure that customers meet their goals and deadlines successfully.
Project Coaching provides experts who work with your team to remove roadblocks and provide guidance during all phases of project delivery.
Neutrinos offers application development services to help you ramp-up your application projects. We provide different team configurations and specialized services; you choose the ones that better adapt to your needs.
- 1 Engagement Manager + 1 Tech Lead + 2 Developers: For new customers who want to accelerate their delivery or to add expertise to a customer team on more complex or mission-critical applications.
- 1 Engagement Manager + 1 Tech Lead + 3 Developers: For customers with business goals clearly defined, with a mature backlog, who need development power to speed up their development throughput.
- 1 Engagement Manager + 1 Tech Lead + 1 Developers: For customers who are still defining their backlog but, at the same time, would like to start working on foundation elements for their applications.
- ½ Engagement Manager + 1 Tech Lead + 1 Developer: For customers who took applications to production and want to focus on post-production activities and troubleshooting.
- 1 Tech Lead + 1 Developer: For customers who want to add experienced development capabilities to their existing teams.
What kind of support does Neutrinos offer?
We want our customers to get the most out of their adoption of Neutrinos. Our teams and experts are dedicated to assisting customers every step of the way:
- Technical support: round-the-clock service desk and a broad and active online community offer permanent technical support.
- Success programs: Tailored for any stage of our customer’s Neutrinos adoption, these programs are designed to provide technical autonomy and ensure customers achieve their business goals.
- Professional Services: Professional Services can support your adoption through a mix of enablement and delivery services.
This is the architectural diagram of the Neutrinos Platform. It consists of many components which help you in rapidly developing your app.
Development and Deployment:
You build your app in the Neutrinos Studio. The studio provides you with a WYSIWIG editor to drag and drop components and design your page.
Using Neutrinos Studio, one can create projects, data structures, pages, etc. and then wire them into congruent applications. You can also wire services to connect your application to back-end systems and with other Cloud services.
Neutrinos Studio is a complete Rapid Application Development (RAD) environment, requiring minimal development efforts. It is available as a web application which can be accessed from a browser, or as a standalone application on Windows, Linux, and Mac operating systems.
Neutrinos Studio is seamlessly connected to Neutrinos Store for you to pull widgets and plug-ins from Neutrinos Store and easily manage dependencies.
Neutrinos Modelr allows you to visually model your application services to link to a variety of backend systems, Cloud Services, and databases. It provides you with 600+ widgets to external systems such as Salesforce, IBM Watson, BPM Engines, etc., as well as connectivity to Internet of Things(IoT) devices.
You can leverage all pre-built digital assets from the Neutrinos Store. This is the marketplace of Neutrinos which empowers you with reusable and standardized assets, including widgets, micro-services, SmartApp templates and, pre-defined data models , and allows you to integrate them with your applications.
Note that you can also contribute assets to the marketplace and monetize the same.
Console is your first point of entry to working with the Neutrinos Platform as you download the Studio from here. This is where you manage builds for the apps that you have deployed from Neutrinos Studio and manage organization users and their access control.
Neutrinos uses OAuth 2.0 protocol. This protocol provides API security via scoped access tokens. Neutrinos IDS provides user authentication and single sign-on (SSO) functionality by maintaining all user’s information. It also grants user tokens to control authorization and authentication, giving you centralized control. It is LDAP compliant and is able to integrate to any active directory of the customer. When you are ready to deploy your app, neutrinos provide you cloud agnostic deployment if you are deploying your app on Cloud. You can click the 1 click deploy option to deploy your app.
If you are deploying your application on-premise, Neutrinos provides you with version agnostic platform run to deploy your app.
The API run time engine of Neutrinos contains all the REST Services, Rendition Engine for all UI, Smart Libraries, and a set of APIs to support deployment of your app on multi-platform of operating systems including Mac, Linux, and Windows.
Neutrinos marketplace of pre-built components, modules and templates is called the Store. These can be downloaded from the store and repurposed to build applications. The development console is integrated with Store. In addition, these components can also be accessed at store.neutrinos.co
The store contains in-house developed templates and modules and also contributions from the Neutrinos developer community. All contributions are vetted by reviewers in house to ensure compatibility, compliance and security.
The application templates, components and modules built by the community is available to use on Neutrinos Studio and complies with the Studio license agreement. While store components and applications built on the studio can be reused to customize applications, redistribution outside the environment is not allowed. To know more about licensing, please contact us here.
The license is shown to anyone using the software before it is downloaded and installed:
A similar notice is shown when installing software from the Forge within Service Studio.
The underlying Neutrinos architecture is not apparent to the end-users of the apps, the developers creating them, or even the operations teams managing them. This article explains the architecture and how it maximizes the performance and security of applications, provides openness to continuous delivery processes, supports continuous innovation. It also demonstrates how a standard architecture is the only way to fully ensure no lock-in to a proprietary solution.
Neutrinos Platform Server is the core of Neutrinos. It is a server component that complements a standard web application server stack with a set of services.
Neutrinos doesn’t use a proprietary runtime engine. All applications rely on standard architectures and frameworks.
Neutrinos Platform Server is what makes this possible. It takes care of all the steps required to generate, optimize, compile, and deploy applications into a standard web application server, or package into a native mobile app, and has a set of specialized services under the hood:
- Code generator: This takes the application modeled in the visual editor and generates, compiles and assembles standard applications, secured and optimized for performance, running on top of standard technologies.
- Deployment services: These deploy the generated applications to a standard web application server, ensuring that your application is consistently installed on each front-end of your server farm / cloud infrastructure.
- Application services: These manage the execution of scheduled batch jobs, and provide asynchronous logging services to store events like errors, audits and performance metrics.
- Mobile apps build service: This packages the compiled mobile app into a native mobile app that is ready for distribution, either through the public or private stores or through Mobile Device Management (MDM) or Mobile Application Management (MAM) tools.
This compiler takes the application model that was developed in the visual editor and generates all the native application components, ready to be deployed to an application server.
When the code generator retrieves the application model, it:
- Runs a deep graph analysis on the application model. This graph is used to check for external dependencies and apply optimizations to the application.
- Checks for optimizations that can be done when generating the code. For example, if an application has a query to fetch data from the database, but the result of the query is never used in the application, the optimizer flags the query to be removed.
- Generates integration proxies to isolate an application from changes made to external services.
- Bundles session management, authentication, and configurations to the application.
- Adds logging and monitoring capabilities to the application, so that developers can check for errors, audits, and performance metrics at runtime.
- Generates the build scripts to upgrade the database model and to deploy the application.
The deployment services deploy the generated application components to an application server and ensure the application is consistently installed on each front-end server of an organization’s server farm.
There are two different deployment components. The deployment service deploys a .NET application on a specific front-end server. The deployment controller coordinates the deployment for all front-end servers as follows:
- The deployment controller uses the Neutrinos code generator to compile the application models.
- Once the application is compiled, it sends the code to the deployment service on each front-end server. The deployment controller then monitors the deployment to ensure the application was successfully installed.
- If all deployments are successful, the deployment controller updates the runtime database to match the data models that were created. If not, the deployment is canceled, and the old application version continues running without changes.
Neutrinos Platform Server also has services for managing the applications at runtime. There are two different services for this:
- Scheduler service: This service manages the execution of scheduled tasks.
- Log service: This service manages the error, audit and performance events of the applications.
Neutrinos Platform Server supports the execution of scheduled batch jobs in applications. At runtime, the scheduling service retrieves the next pending job from the metadata database and executes it.
Batch tasks are designed for horizontal scalability so they are distributed across all the front-end servers.
Applications are automatically instrumented to create error, audit, and performance logs. At runtime, these metrics are captured asynchronously, so that the performance of applications is not compromised while they create a constant stream of metrics.
The log service runs at a lower priority so that it doesn’t compete with the normal processing of applications. At runtime, when an application generates an error, audit, or performance event:
- The event is written to a standard message queue on the front-end server.
- The log service running on the front-end server asynchronously retrieves the events from the message queue and adds them to the logs database.
- The events can then be leveraged by the monitoring consoles to display errors, audits, or performance data. They can also be sent to external systems by using available APIs.
Mobile apps build service
The Mobile Apps Build Service (MABS) is the platform service responsible for packaging a mobile app into a native app package ready to be installed on mobile devices. MABS is designed to be a highly scalable service that completely abstracts the complexity of compiling, packaging, and signing a native app for iOS, Android, or both, so that development teams get a streamlined experience of building a mobile app with 1-click from the back-end to native front-end.
Each request to MABS is queued and processed in parallel in an isolated sandbox to ensure that information is always secure. All communication with MABS is done via the Platform Server and through HTTPS, and only the necessary information to execute the build operation is sent to MABS. This means that no backend logic information is sent. MABS stores all information with encryption and only for the minimum necessary time to complete the process.
The build process that MABS executes is:
- Create a new project in an Neutrinos template that provides the base native app structure and default native capabilities.
- Process app resources (icons, splash screens, configurations).
- Set the mobile platform: iOS or Android.
- Add native plugins.
- Process keys to sign the app.
- Build package.
When the mobile package is created, we delete all your information, collect the application package, and return it to you.
Standard architecture with no lock-in
Neutrinos takes your application models, and generates standard and optimized applications that are ready to run on a standard web farm or cloud architecture. Neutrinos also uses a standard relational database to deploy and store all data that your applications use.
Once generated, applications can run independently of any Neutrinos components, and all of your application data remains under your control and accessible with standard tools.
This approach ensures that:
- The applications you create are optimized for performance and security – whenever you redeploy your models, Neutrinos regenerates the applications with the latest security protections or performance optimizations. We leverage best of breed code patterns, validated for security best practices during our engineering processes, and optimized for performance across all different types of workloads across our diverse customer base.
- Your applications are compiled to standard code, using non-proprietary frameworks. As technologies evolve, Neutrinos evolves its compiler, taking advantage of new frameworks or new framework capabilities, and abstracting you from such changes.
- Your applications run on top of standard web application servers and databases, independent of Neutrinos proprietary components. This gives you the flexibility to deploy your apps using any Infrastructure as a Service (IaaS) provider, or on-premises. You also retain control of the underlying infrastructure components over which you can use your standard processes and tools (e.g. for application monitoring or security scanning)
- You’ll never be locked-in to Neutrinos. Given Neutrinos generates and deploys standard applications, on standard technologies, with a standard database model, your investment is always protected. At any point, if you ever stop your Neutrinos subscription, you can retrieve and keep:
- The last version of the generated source code for your applications – so you can deploy and run them in your infrastructure with no need for custom interpreters, runtimes or any kind of proprietary library. If you have to make small changes to your applications, you can do so with standard tools (e.g. change them with Visual Studio, manage them under a standard source control system).
- Your application data, in the last version of your database schema – so you can continue to use existing data for existing applications, progressively migrate or integrate it from other applications, or just keep it for historical purposes.
Architecture of generated apps
Neutrinos includes a unique deployment engine capable of generating and deploying standard web or mobile hybrid applications from a comprehensive set of visual models
This approach allows developers to focus on modeling their applications in a way that best suits particular business requirements, supporting low-code integration with other services or technologies, while ensuring continuous functionality, security and performance updates via our optimized code-generation technology.
Neutrinos standard architecture with no lock-in, ensures that your IP and investment is protected in case you ever wish to discontinue your Neutrinos subscription.
Without requiring any proprietary components, runtime engines, or interpreters, applications are generated into a fully open, standard, optimized and documented set of server and client components, deployable to a standard web server.
The Neutrinos compiler is an ever evolving component. We employ best practices for performance and continuous updates on the security of your applications.
The target architecture of applications we generate is constantly evolving. The platform is architected in a modular way that allows Neutrinos to easily generate new architectures. This ensures:
- If a vendor discontinues the support for one of the technologies we use, that change won’t affect your applications.
- Developers are isolated from constant technology shifts and breaking changes in the underlying frameworks.
- Your applications benefit from new technologies and frameworks that will bring all kinds of non-functional improvements
Independent of the languages and architecture in which applications are generated, we are constantly working so that they run with the highest quality, performance and security – you benefit from this abstraction and all the best practices employed by our expert engineers and architects, and your end-users benefit from higher quality and higher performance applications.
High level application architecture
Applications created with Neutrinos include three types of components: generated, runtime and custom backend extensions.
The following diagram provides an overview of how an application is split among its underlying components:
These components are created automatically whenever an application is submitted for compilation and publishing. The generated components include:
- REST APIs and SOAP web services are directly generated and exposed as backend endpoints. The corresponding contracts (.json Swagger or .wsdl files) are also generated. In addition, a set of REST APIs are automatically created by the platform as the backend services for your mobile applications.
- The backend / server logic that supports your business rules, background job logic, and APIs are generated as optimized server code. Proxies to other referenced applications are included in the backend logic as assemblies. This abstraction means apps reusing the services are unaffected when the implementation of the service changes.
There are a set of components included in every application that support the base functionality, including base rendering capabilities and access to various services within the Neutrinos platform:
- Generic Platform Library: Client or Server side classes and methods used in all generated applications, such as the Neutrinos built-in functions available in Service Studio, database connection management utilities, Excel workbook management, site properties management, Ajax server side utilities, or timer related utilities.
Custom backend extensions
Assembled in Integration Studio, these custom components extend Neutrinos and allow you to include custom code in your applications.
These components are used in the context of any application that references them, and the code is executed in the front-end server where the application is deployed.
They contain the implemented assemblies directly compiled or included through Integration Studio, along with the extension’s additional resources
Full stack optimizations
Whenever you publish an application model (e.g. through Service Studio or when staging an application between environments) the source code of the application is (re)generated, compiled, packaged and deployed.
Neutrinos automatically generates and applies a set of differential DDL scripts that are used to updated the database schema based on any changed entities (tables).
This ensures that, at any point, one application model can be consistently generated and deployed to a target environment. It also means that at any point you can revert / rollback to any application version, since all changes are non-destructive and determined based on the current state of the target environment.
The compiler enforces a series of rules and optimizations that ensure applications behave correctly, with native performance, and avoid scalability or reliability issues.
Such rules and optimizations are applied across all layers of the application to ensure the best performance, from database accesses to web page size. Examples include:
- Pages are compressed. To assure that minimal bandwidth is used by applications and that requests made by users are served faster, all pages are automatically compressed to reduce their size.
- Web Pages can be partially rendered: By taking advantage of the built-in support for Ajax, the application pages can be partially rendered, thus sending less information to the server and returning only a part of the page. The result is less bandwidth consumption, better responsiveness and an improved user experience.
- Ajax requests are always queued: The generated code assures Ajax requests are always queued so that a given user cannot flood the web application server by sending multiple requests simultaneously to the server.
- Duplicate Ajax requests are dropped: The generated code also assures AJAX requests are only sent once to the Web Application Server, thereby preventing an increase in server load. For example, if several requests from an AutoComplete pattern are queued in the browser, only the last one will be sent to the server.
- Graph analysis to send only the necessary fields to the view state: By using advanced graph algorithms that verify which scope variables are written, read, or not accessed at all, the Neutrinos compiler generates code ensuring only essential fields are sent to the View State, thus highly optimizing the size of the page.
Neutrinos enables the modeling of complex business logic without writing code, instead using only simple visual constructs like conditions, cycles, nested calls, assignments, queries, and a wide range of other prepackaged or extended visual building blocks.
These building blocks and services save a lot of work while ensuring that the application is an enterprise-class system. This is because features like transaction handling, auditing, exception handling, Excel file handling, integrated authentication, and user/profile Management are services that are available as visual out-of-the-box elements in Neutrinos.
Moreover, Neutrinos leverages a full reference-checking and self-healing engine (TrueChange) that assures error-free and consistent changes across all application components. For example, whenever someone modifies a business rule, this engine automatically updates all related business services, data, and user interface elements that use that piece of logic.
Batch processes are throttled
Neutrinos allows developers to model business logic that executes asynchronously. Since multiple asynchronous batch processes are possible, these are automatically throttled to ensure that even heavy loads of badly programmed scheduled activities do not take all the processing power required to serve application users.
You can create, model and integrate persistent data repositories based on third-party databases without resorting to traditional complex SQL statements.
Neutrinos handles database creation, tuning and integrity with your application during any refactoring operation.
As far as database performance is concerned, the applications include a set of optimizations. These are:
- Connections are pooled: This enhances the performance of executing database commands and reduces the amount of time a user must wait for a connection to the database to be established. Connection pooling also avoids the excessive use of operating system, network and database resources that would derive from having one connection per user accessing the application.
- Connections are only kept open if needed: When they are no longer of use, they are automatically released. This allows greater scalability with reduced database resources consumption.
- Transactions are always committed or rolled back and then released: Regardless of what the developer modeled, in the end they are always released – either by committing or rolling back – assuring your application leaves no orphaned transactions or locked tables and does not consume unnecessary resources.
- Queries are only copied to memory if needed: This assures that applications consume the minimum possible amount of memory, despite the fact that they can handle massive data.
- Query fields are only fetched if required: Advanced graph algorithms verify the usage of fields within business logic and user interface so queries exclusively fetch the required fields from the database. This ensures minimal load on the database and minimal data transfer latency, regardless of what the developer coded.
- Queries are contained for duration: If, even with all these optimizations, some queries take too long to execute, Neutrinos automatically discards them based on a timeout, to ensure the database is not affected by heavy queries, which enables applications to perform at an optimum level.
- Tables have automated indexing for primary and foreign keys: This optimizes the most common database queries. If more advanced queries require extra indexes in the tables, those can be visually created when your are modeling your data Entities.
Neutrinos is extensible with a platform, environment, tools and features that enable customers to:
- Extend the back-end: If the visual language used in the visual editor is not expressive enough, additional components may be written using custom code. In addition, developers can search Forge for existing components to speed up development.
- Integrate with existing systems: In the visual editor, it’s possible to integrate with SAP systems, and consume REST APIs and SOAP web services. If there is functionality that is not supported, there are hooks available to extend the integration with custom code.
- Integrate with your databases: Neutrinos is designed to be independent of the database you use. That’s why we support the most common enterprise-grade database systems. However, our database SDK can also be used to extend Neutrinos for integration with databases we do not support.
- Integrate with your authentication provider: Neutrinos has built-in authentication management for your application and IT users. In addition, support for Active Directory and LDAP integration is included. If there is an authentication system that is not included with Neutrinos, our APIs can be used to extend Neutrinos to support it. It’s also possible that there’s already a Forge component built by the community, to integrate with the authentication provider of your choice.
- Customize the management consoles: If our management consoles don’t include what our customers need, they can extend them using our SDK. These consoles are built with Neutrinos, so no one needs to learn another technology to extend them.
- Integrate with your IT processes: Neutrinos includes APIs to integrate the deployment of Neutrinos applications with your existing DevOps tools and processes.
How does Neutrinos fit in an enterprise architecture?
Neutrinos fits perfectly in an enterprise ecosystem. Organizations can build a service-oriented architecture (SOA) that promotes service distribution over three levels: external API, core services, and integration services. Services can be tightly coupled in Neutrinos applications to take advantage of the full capacity of the platform or completely decoupled in a microservices strategy for promoting CD/CI. As a result, organizations can easily update and permanently align their architecture with business strategy.
Neutrinos and the enterprise ecosystem
After evolving over the years, an enterprise ecosystem usually consists of legacy systems and corporate databases from different vendors. Furthermore, these components exchange information and APIs with external systems, satellite apps, and web portals. The result is often a “spaghetti” architecture that makes it difficult to maintain and evolve digital support for an organization’s business strategy.
The main issues that surface are:
- Poor service abstraction: Services for core business concepts are not correctly isolated and abstracted. Business rules are spread over different systems and code reuse has very little structure.
- Unmanageable system dependencies: Systems are not correctly isolated from each other so updating or replacing a system has a snowball effect on other systems. Having an enterprise service bus (ESB) to unify the communication between different systems helps. However, it cannot ensure system independence if the representation of business concepts is not properly normalized and too much business logic is placed in the ESB itself.
- Inflexible, slow-moving legacy systems: Quickly adapting a legacy system to business changes is difficult. If the system is complex and inflexible, changes can take a long time. Sometimes the technology is obsolete. And, the accumulation of core information and system dependencies over time can hinder any replacement.
Because of its nature, Neutrinos is the right choice for complex enterprise architecture. It enables organizations to address enterprise IT trends of composable apps, decoupling the front-end from the back-end, and abstracting reusable services. These services can be loosely coupled in a microservice architecture. Or they can be strongly coupled when monoliths are a better fit—for example, a scenario where all the consuming applications are in the same CD/CI pipeline—thus benefiting from single database transactions and avoiding the extra complexity of managing a distributed solution.
How are services supported? By providing visual modeling and the rapid creation of back-end services for either non-Neutrinos consumers (exposing REST or SOAP APIs) or for other Neutrinos consumers (either exposing strongly coupled actions or loosely coupled microservices). Organizations can innovate and differentiate while leaving the role of supporting the commodity functionality to slow-evolving legacy systems.
Typically, Neutrinos is positioned in an enterprise ecosystem as illustrated by the following diagram.
A set of Neutrinos services provides core functionality that is either fully implemented in Neutrinos or that extends and normalizes functionality from external systems or records. Examples of the latter are external producers like ERP, CRM, or corporate databases.
These services can be reused by Neutrinos web or mobile applications and microsites, which are small web applications that run in an iFrame of another website. They can also be used by external consumers, external portals, and other applications not developed with Neutrinos.
Building services with Neutrinos
Building a service-oriented architecture that powers the constant digital revolution of a modern enterprise, following sound architecture principles, is important. These principles ensure that Neutrinos is correctly implemented in the surrounding ecosystem and value-added services are properly designed.
A framework for designing a solution architecture
An Neutrinos architecture design framework enables correct implementation and design. Four layers make designing SOAs simple. The framework promotes the correct abstraction of reusable services and the correct isolation of distinct functional modules. The result is a set of modules with more independent lifecycles and without unmanageable dependencies, creating an architecture design that is easy to maintain and evolve.
Each layer in the framework addresses a different aspect of the functionality in a module:
This framework is used in two different stages of architecture design:
Identifying concepts, such as functional, non-functional, and integration needs. The framework collects architecture requirements systematically and with structure.
Defining the modules that implement the identified concepts, following recommended patterns.
Designing architecture is not a one-time event. It is a continuous process. The architecture must be iterated by cycling through these two stages as a solution evolves and new concepts and needs emerge from the business.
The Electronic Canvas tool, which is available in Neutrinos Forge, enables the placement and movement of concepts in a digital framework for identifying and organizing all the architectural elements needed to implement a new project.
Three rules for a great architecture
To ensure that architecture is correctly abstracting reusable services, isolating end-user processes, and avoiding unmanageable references, organizations should follow these rules:
- No upward references: An upward reference indicates that services are not isolated at the correct layer. These references are the major cause for complex unmanageable dependencies that can evolve into huge clusters of modules in direct or indirect cycles.
- No side references for orchestration or end-users: Orchestration and end-user modules should not provide reusable services. This ensures that they are correctly isolated and don’t interfere with each other’s lifecycles.
- No cycles between services: Conceptually, a service normally depends on or extends another service. A cycle typically shows that the concepts are not correctly isolated. For example, there are misplaced elements. Or it indicates that there is a need to isolate a third and more general concept that depends on the others.
Verifying these rules in a complex system and running these checks as the system rapidly evolves can be difficult. Automated mechanisms can help.
The Neutrinos architecture design framework takes care of the rule breakers. The Discovery tool automatically verifies compliance with the rules. It analyzes the actual dependencies between modules and identifies what actions, screens, entities, and other elements need to be corrected. Complexity is kept under control, saving time so more value-added tasks are the focus.
Services as the core of enterprise architecture
The principles of the architectural design framework are the key to guiding the design of an Neutrinos solution and correctly integrating it into an enterprise ecosystem. Applying these principles enables a clear separation of services and applications. Neutrinos applications and microsites are primarily composed of end-user and orchestration modules. The services that support Neutrinos and other applications are composed of core and foundation modules.
The Neutrinos services can be exposed by SOAP web services or REST APIs, both of which are language-agnostic and easily consumed by other technology. For the internal consumption of services, Neutrinos supports both loosely and strongly coupled services. With support for loosely coupled services, organizations can implement a microservice strategy with independent CD/CI pipelines. Support for strongly coupled services allows access to the full potential of the Neutrinos platform where total independence between applications and services is not a requirement.
In both scenarios, Neutrinos mechanisms are used to their full potential, namely performing impact analysis, searching for services inside the IDE, and managing security.
Service distribution over three levels
This service architecture example shows how Neutrinos promotes service distribution over three levels: external API, core services, and integration services.
Neutrinos makes it easy to apply these principles, so core services are correctly isolated from external systems to minimize impacts from ecosystem changes. Ideally, only the external API is affected when an external consumer is changed, added, or removed, while the same actions for an external producer affect only integration services.
External API level
The composition of APIs that expose services to external consumers occurs at this level with REST, SOAP, or others. No business logic is added. This level is a technical wrapper for the real services implemented in the core services layer, translating those services to the APIs agreed with external systems and eventually adding some integration logging if required.
Core services level
Implementation of the service itself occurs at this level with all the business rules and core entities. Core services should be system-agnostic.
If the core service extends an external system of record, the integration is abstracted by an integration services layer. This layer is simply a technical wrapper for normalizing data structures and abstracting integration complexity, such as recovering from errors and authentication for external systems.
Neutrinos Cloud architecture
With a subscription to Neutrinos Cloud, an organization’s infrastructure is automatically provisioned, configured and tuned for high availability, performance, security and reliability:
- Infrastructure provider: The physical infrastructure of Neutrinos Cloud is hosted in the secure data centers of Amazon Web Services.
- Starter environment configuration: The starting configuration for Neutrinos Cloud is one production environment and two non-production environments.
- Supported stack configurations: Neutrinos Cloud allows organizations to choose their preferred database engine (Microsoft SQL or Oracle).
- Infrastructure geography: Neutrinos Cloud gives organizations the freedom to deploy their applications on an infrastructure that is physically distributed around the globe.
- Infrastructure multi-tenancy isolation: Support for multi-tenancy—hosting multiple customers (or tenants) efficiently in the platform layer while keeping them isolated—is a basic aspect of Neutrinos
Amazon Web Services (AWS) is the market leader and the most mature public cloud infrastructure as a service (IaaS). It has enterprise-grade availability with guaranteed service levels of 99.9%, and it is the IaaS technology that has been accredited by the largest number of security compliance standards.
Although Neutrinos Cloud runs on Amazon AWS, customers are not locked-in to a single IaaS vendor. The Neutrinos platform internal architecture abstracts the IaaS layer, which enables portability between IaaS vendors.
Starting environment configuration
The starting configuration for Neutrinos includes three environments:
Multiple environments enable organizations to develop and test the functionality of their applications and integration before deploying them to production or releasing them to customers. Environment separation also allows better access control. There is less risk in development. Making a mistake in a development database is different from making a mistake in a production database, for example. In scenarios with sensitive personal data, the data is protected because development and QA teams do not use this data in their tests.
The starter configuration is adequate for a team of up to five developers who are doing their usual daily work. In production, it is capable of serving up to 30 requests per second and supporting approximately 600 concurrent users based on benchmarking against a well-designed and scalable application.
The physical architecture of the starter configuration includes the following:
- Development, test and production front-end servers. Each front-end server is an isolated virtual instance with a set of resources well-suited for developing and running mobile and web applications with Neutrinos. Each front-end server has 4 GB of memory and 2 virtual cores.
- Management (lifetime) front-end server. The management front-end server is a virtual instance, isolated from the other environments, with 4 GB of memory and 2 virtual cores.
- Database servers. Each database server is a virtual relational database instance with 3.75 GB of memory, 1 virtual core and 100 GB of storage capacity.
- Virtual private cloud (VPC). The VPC service provides a logically isolated private network for an organization’s Neutrinos environments. This allows the cloud environments to communicate with the organization’s on-premises systems over an IPsec VPN tunnel, thereby enabling organizations to leverage Neutrinos as a secure and seamless extension to their data centers.
If additional scalability is needed to meet performance requirements, the Neutrinos Cloud infrastructure can be scaled on demand.
Supported stack configurations
Neutrinos deploys applications to a standard operating system and application server, without any proprietary runtime engine.
For the database engine, the options are Oracle or Microsoft SQL Server. Organizations can take full advantage of their underlying capabilities by using either the Neutrinos visual query capabilities or the tools they already have.
The visual modeling capabilities abstract the underlying stack and ensure portability between stacks. Neutrinos allows developers to:
- Deploy their own existing traditional code and libraries to Neutrinos so they can easily reuse logic they have previously built.
- Create components in traditional code that can use the full scope of the underlying stack. Neutrinos automatically catalogs these components and makes them available to other developers who can then use them to assemble new applications visually.
- Package integration adapters written in native languages and deploy them to Neutrinos. Once deployed, these custom integration adapters become available as new visual building blocks that developers can use in their applications.
This extensibility makes Neutrinos very flexible and enables developers to leverage existing development skills, while deploying code to the cloud, instead of having to comply with complex and custom cloud-deployment containers. It is also a great benefit should an organization decide to migrate from our public cloud infrastructure to its own data center or to a different IaaS provider. This architecture will never lock an organization to a particular cloud or deployment model.
When subscribing to Neutrinos, organizations choose the region(s) they will be using. The following regions are available:
- In Asia Pacific: Sydney, Singapore, and Tokyo
- In Europe/Middle East/Africa: Ireland, Frankfurt, and London
- In the Americas: United States (Northern Virginia and Oregon), and Canada
Whenever possible, organizations should consider locating their Neutrinos instance in a region that reduces distance (and latency) to optimize application performance and data transfers.
For more details, see Choosing the AWS Regions for an Neutrinos Cloud deployment.
Additionally, to meet legal requirements, organizations can select the regions to ensure that specific data resides in a specific region.
Infrastructure multi-tenancy isolation
In the Neutrinos Cloud, multi-tenancy is provided by the underlying AWS IaaS and its virtual machines logically isolated from other tenants. At the database level, the multi-tenancy is assured by the Amazon Relational Database Service (Amazon RDS), where each database instance operates logically isolated. Additionally, Neutrinos prevents cross-tenant access by making sure each tenant’s front-ends and database instances share a Virtual Private Cloud exclusive to the tenant.
This VPC isolation is preserved even when scaling resources. The Neutrinos infrastructure can grow to accommodate demand spikes or additional capacity with no impact on other customers, and Neutrinos guarantees that the additional resources will be part of the customer’s VPC.
Each Neutrinos customer’s applications share the customer’s common isolated set of environments and are deployed independently of each other, even though they share the same resources. The entire application portfolio shares the same optimized infrastructure and scales evenly as new computing resources are added.
By default, customers activate their subscription on the Neutrinos Cloud and start developing and delivering applications immediately. But Neutrinos was designed also for other clouds (private or public), on-premises or hybrid deployments. The Neutrinos architecture guarantees that there is no loss of functionality and enables developers to move from the public cloud to an on-premises installation if need be.
Here’s a high-level overview of the possible configurations:
- Neutrinos Cloud: Subscribe to the Neutrinos Cloud to get the platform immediately provisioned, configured and tuned for high performance, security and reliability. Neutrinos takes care of the infrastructure and provides both self-service options and a portfolio of admin services in a simple-to-use offering.
- Other public clouds: For organizations that require deep control of their infrastructure and want to take advantage of the infrastructure services offered by public cloud vendors, Neutrinos can also be provisioned in any other public cloud service.
- Private cloud and on-premises: Some organizations need full control over enterprise and customer data, or have very specific requirements for security and regulatory compliance. Developer teams can install Neutrinos in a private cloud, colocation data center, or on-premises.
- Hybrid: It’s possible to combine the various deployment models, distributing Neutrinos deployments across public, private or on-premises environments, leveraging the unique benefits of each.
Deploying Neutrinos in the cloud
Neutrinos is available as a Platform as a Service (PaaS), providing enterprise-class cloud computing power without the hassle of managing physical software infrastructure. This is called the Neutrinos Cloud, and deployment is automatic. Neutrinos can also be deployed in other public clouds.
Deploying Neutrinos Cloud
When organizations subscribe to the Neutrinos Cloud, their infrastructure is automatically provisioned, configured and tuned for high performance, security and reliability. The Neutrinos Cloud physical infrastructure is hosted in the secure data centers of Amazon Web Services.
For more details, go to Neutrinos Cloud Services Overview and Neutrinos Cloud Architecture.
Support for other public clouds
Neutrinos can also be installed in any other public cloud service provider of an organization’s choice, such as Microsoft Azure, Rackspace or VMWare.
Customers who use these clouds must install and manage Neutrinos themselves. For detailed information about the platform installation requirements and process, read: How to install Neutrinos.
Choosing the region for and Neutrinos Cloud deployment
The choice of AWS Region is especially important in the following scenarios:
- On-premises integration performance: Reduced distance and latency is important when organizations are integrating applications with legacy services or applications hosted in their own data centers and if they plan to engage in long-term hybrid or on-premises to cloud scenarios.
- Collocation with external cloud applications and services: In scenarios where organizations are already using AWS cloud services, the advantages of deploying Neutrinos in the same region include decreasing communication latency and reducing data transfer costs for other AWS infrastructures.
- Application performance for end users: Organizations can provision resources closer to their end users, so they have a better experience when running their applications, especially when they are concentrated in a single location.
In global organizations, the application of these criteria may not be obvious, when both application users and internal information systems are scattered around the globe.
Rather than choosing only one region, global organizations can choose a different region for each environment.
Environments in different regions have independent databases and URLs. With environments in different regions, organizations can also choose which applications and versions to deploy in each region, and when.
A list of the AWS Regions supported in the Neutrinos Cloud is available in the Neutrinos Cloud Architecture section.
If I start on the cloud, can I transition to on-premises later?
Yes. Neutrinos is designed for portability between data centers. Application data, meta data, configuration data and source code are all carried through to the database, making portability much simpler than with other technologies.
At the end of a transition, all applications will continue to run as before, with all the great functionality an organization’s users have grown accustomed to.
The transition to on-premises entails the following steps:
- Install the platform in the new data center.
- Ensure connectivity to all integration points and external data sources.
- Migrate the data.
Deploying Neutrinos on-premises
Neutrinos can be installed on the private cloud of a third-party vendor or in an organization’s data center.
Neutrinos on a private cloud:
For detailed information about the platform installation requirements and process, read: How to install Neutrinos.
Hybrid deployment of Neutrinos
With Neutrinos, you can combine deployments, thereby distributing Neutrinos over public, private or on-premises environments, leveraging the unique benefits of each. This hybrid mode is typically used for customers who want to build and test in the public cloud (Neutrinos or third-party) and then deploy in a private cloud or in an on-premises environment. This enables them to take advantage of the unique benefits of each, based on the functional requirements of the application.
For detailed information about the platform installation requirements and process, read How to install Neutrinos.