Intrexx Alternative - Appollo Low Code Platform

Today, you can find more than 100 low-code platform provider and there are many alternatives like Intrexx , Mendix or Outsystems. Many of them can be compared e.g., at Sourceforge Software Products.

Start reading what makes Appollo so different.



Easy to learn, easy to understand, graphically configurable

Understanding of Low Code

A common understanding of low code is to develop apps using graphical elements, configured and connected by drag&drop, instead of writing millions of lines of code.

Today, there are much more than 100 alternatives of low code platforms, like Mendix, Outsystems or Intrexx. But there‘s a huge difference, especially since many do not model graphically or use dialogs to configure data with highest risk of inconsistencies.

Benefits of Appollo

In Appollo everything is graphical, particularly the data models are graphically represented.

Business and all stakeholders easily understand all graphical modeling, from data model, user interface, process to backend.

For any apps, complex automation, industry & IoT solutions

Understanding Types of Apps

Today, most of low code alternatives are either specialized for mobile app development, like Mendix, Intrexx or Outsystems, or process digitalization, like Pega. According to Gartner, companies are using up to 4 low code platforms to fulfill all business needs.

Also the low code efficiency is different. Which means that dependening on the complexity of your app, you are mostly required to use high code and high professional IT developers in an early stage.

Benefits of Appollo

Appollo provides the development of mobile app, web app, core enterprise apps and process digitalization as well as industry and IoT solutions of any complexity. Even highest complex apps can be developed visually by no-code up to 95%, only 5% remains in simple JavaScript coding, which means a few lines of modularized coding of business logic.

Apps are online at the push of a button, without IT support but highest security

Understanding App Delivery

Application delivery must consider 3 major aspects.

  • Performance
  • Security
  • Ease of Use


Benefits of Appollo

As a precondition, Appollo seamlessly integrates into an existing infrastructure, thus avoiding shadow IT.

Application delivery is just a click at a button without any IT support. Publishing takes place within seconds.

As an outstanding feature, Appollo provides publish application functions right a way, without any restart of the current application for highest availability.

Runtime access can be configured with fine-grain access rights.

The only all-in-one platform that supports the entire application life cycle

Understanding App Life Cycle

The Application Life Cycle consists of five phases

  • Analysis
  • Design
  • Development
  • Test
  • Operation

Benefits of Appollo

Appollo not only supports low code development but all phases of the application life cycle. Starting from Business Analysis and Design, up to Test Automation and Operation.

As an outstanding feature, Appollo has an integrated  graphical issue management, including also a Kanban board for an agile project management.

None of the well-known low code alternatives, like Intrexx, Kissflow, Bizagi and many more do not provide the entire application life cycle starting with business analysis and design with a seamless tranistion into low code development.

Up to 10x faster than traditional programming, significantly lower costs

Understanding Low Code Speed

Typically, low code speed is measured using the duration of low code development phases.

Besides that, there is a high potential to speed up application delivery during all phases of the application life cycle.

Benefits of Appollo

Supporting all phases of application life cycle, the Appollo Low Code Platform provides you the potential to significantly increase application delivery, up to 10 times faster than conventional development methods.

This ultimately leads to a significant reduction in development, operation and maintenance costs.


is more than just

Low Code


Visualize a complete enterprise analysis for heatmap derived strategic decisions

Support for Digital Transformation and Innovation

  • Use Appollo from the very beginning
  • Make a complete enterprise analysis
  • Conduct a strategic consulting by identifying gaps, risks, benefits and recommendations
  • Document all findings, risks and recommendations directly at the graphical model and element using the integrated issue management
  • Discuss strategic decisions on a heat map-based evaluation of such issues
  • Drill-Down to any detailed model of your analysis
  • Seamlessly continue with business analysis and requirements engineering for most critical uses cases
  • Use one common tool context for all stakeholders and for all phases of digital transformation

From today’s point of view low code alternatives, you can compare IBM BPM, Intrexx, LANSA, AgilePoint or whatever provider, none of them will start with a strategic analysis of digital transformation on their platform.


Use more than 20 model types for a detailed graphical business analysis

Support for Business Analysis and Requirements Engineering

Use more than 20 model types and the integrated issues management for a graphical business analysis and requirements engineering.


  • Close the gap between business and IT
  • Avoid misunderstandings and miss implementation to speed up delivery time
  • Instead of writing business requirements in kind of Word, Excel or PowerPoint, deliver graphical models and user stories up to evolutionary prototypes of your use cases


  • Work together using one common visual language and one common tool context
  • Add attachments and description to each model or model elements

Support for business analysis and integrated requirements engineering speeds up app development but is hardly to find it in other low code alternatives like Neptun, Simplifier, Axon Ivy, Intrexx and many more.

    Create graphical user stories for a seamless transition into low code development

    Issue Management

    Appollo provides an integrated issue management, where issues like user stories, requirements or bugs can be directly added to a model or even an element.


    • Developers directly know where to fix the issue
    • Project planning and controlling on one platform


    • Create your sprints to provide an agile project management and assign issues to the developers
    • Issue creation and verification directly at the correct model and element

    The integrated graphical issue management is a unique selling proposition of Appollo and supports for faster app develeopment and maintenance as well as project management. Therefore evaluate low code alternatives e.g., at saasworthy, like Caspio, WaveMaker or Intrexx and many more.


      Use BPMN standard for the digitalization of processes

      Process Digitalization by BPMN Standard

      Other alternatives like Intrexx or Mendix provide workflow automation. But most of them don’t use BPMN as process standard. With the Appollo Low Code Platform, you can easily create high complex process digitalization using the BPMN standard and directly connect to any kind of Mobile, Web or Core Enterprise Apps by no-code.


      • Graphical development of any kind of complex process.
      • Out-of-the-box integration of process-to-mobile app communication.
      • Usage of a well-known industry standard.


      • Realize your workflows by just drag&drop and no-code configuration
      • The graphical model represents exactly what is executed at runtime

        Use CMMN standard to include dynamic case management into your business processes

        Dynamic Case Management by CMMN Standard

        The Appollo Platform offers the possibility to use Dynamic Case Management based on the CMMN standard for dynamic or document-centric workflows.


        • While processes are rather static, more dynamic use cases can be easily automated by Dynamic Case Management
        • Case Management offers a high flexibility while still follow the established guidelines


        • Create your case plan by drag&drop and integrate them seamlessly into your workflows by no-code

        Dynamic Case Management is important in many business and public sectors. Therefore also some of the low code providers offer this feature but evaluate e.g., alternatives like PEGA, Intrexx or Mendix if they can provide it according to the CMMN standard, like Appollo.

              Use DMN standard and nestable decision tables for your business rules

              Rules Engine and Decision Tables by DMN Standard

              Appollo provides an integrated Rules Engine based on the DMN standard to integrate your business rules.


              • Any kind of nested decisions can be modeled understandable and maintainable even by the business departments
              • Simplifies the design and execution of the business rules within a business process by drag&drop and no-node


              • Use any kind of input and output data to visualize the business rules and integrate the decision tables directly into your process

                      Use PWA progressive web app technology and one single code base for both mobile apps and web apps

                      PWA Technology for Mobile App

                      Other alternatives like Outsystems or Intrexx create native Apps. The Appollo Low Code Platform instead provides the progressive web app (PWA) technology for mobile app development.


                        • Use one single code base for both mobile apps and web apps
                        • No app store is required



                        • Configure a mobile app with just a couple of clicks
                        • Install the app at your home screen directly from the browser
                        • Optionally, your app can be published into any app store

                                    Use more than 50 no-code configurable UI Elements from simple to high complex pixel-perfect user interface

                                    More than 50 UI Elements

                                    Design any complex user interface with more than 50 UI elements, including tables, google maps, charts and many more.


                                      • Create complex UI pages in nearly no-time


                                      • UI elements are highly configurable by no-code
                                      • capture events by no-code to easily implement event-based condition, UI validation and UI page flow action
                                      • easily configure a fine-grained visibility and access control of UI elements
                                      • add individual CSS styles or setup your corporate design
                                      • adjust a pixel-perfect responsive design for any device

                                                Easily integrate any kind of individual custom UI components for an unlimited user experience

                                                Support for Custom UI Component

                                                The Appollo Low Code Platform provides the possibility to easily integrate any kind of individual custom UI component available on the market.


                                                • There is no limit for your creativity to design for gorgeous user experience


                                                • Comfortably edit the HTML, JavaScript and CSS of the custom UI component in the UI editor of the Apollo Low Code Platform
                                                • Directly integrate the UI component by No-Code into any UI page. Just map your data attributes and connect the UI page flow in a User page flow model based on custom UI event
                                                • Reuse a UI component in any UI page

                                                              FASTER TIME-TO-MARKET & HIGHER QUALITY

                                                              Generate and reuse UI components for high speed delivery and zero fault tolerance

                                                              UI Component Generation

                                                              The Appollo Low Code Platform provides the possibility to add multi-lingual user interface properties and validation & default values directly at the data attribute.


                                                              • Generate multi-lingual UI components including all necessary validation directly from your data objects in seconds
                                                              • Lengthy translation effort or scripting of validation rules on User Interface elements is a thing of the past


                                                              • Add labels, placeholders, tooltips or error messages multi-lingual directly at the data element
                                                              • Integrate all validations, like range, length, regular expressions or validation functions on data level

                                                                              Modularize large enterprise-grade projects into subprojects to integrate reusable components by no-code

                                                                              Project Modularization

                                                                              To support large scale projects, the Appollo Low Code Platform enables to modularize enterprise grade projects into subprojects.


                                                                              • Reuse specific parts of the application, like external system integration, as a library over many projects
                                                                              • Reduce maintenance and familiarization by working with small sized projects


                                                                              • Communicate between subprojects by calling specific API models by no-code from your process, your mobile app or web app
                                                                              • Integrate previously created components into your new project by no-code to ramp up the development
                                                                              • Use GIT-based version management and branches

                                                                                              ALWAYS-ON APPLICATIONS & ON-THE-FLY DELIVERY

                                                                                              Publish-lock-unlock microservices for highest availability and maintainability without downtime

                                                                                              Highest Availability

                                                                                              All models are considered a microservice, which means they can be published independently.


                                                                                              • Achieve highest availability by publishing change request and new features without server and application downtime
                                                                                              • Avoid financial or reputation damage by locking faulty services while still continue using all other application services
                                                                                              • Avoid testing effort by only testing the newly published models


                                                                                              • In case of an issue in your application, you can directly lock a specific microservice, while the rest of the application is still running smoothly
                                                                                              • Unlock it again when the issue is resolved without downtime

                                                                                                REDUCTION OF TOTAL COST OF OWNERSHIP AND CHANGE

                                                                                                Full application lifecycle support to significantly reduce development, operations and maintenance costs

                                                                                                Cost Reduction

                                                                                                Appollo supports the full application life cycle.


                                                                                                • By supporting the full application life cycle the Appollo Low Code Platform reduces both the total costs of ownership and the total costs change


                                                                                                • Start using Appollo from the very beginning of your innovative idea
                                                                                                • Invite stakeholders and end users for an efficient collaboration
                                                                                                • As a business analyst, deliver prototypes for a seamless transition into low code development
                                                                                                • Deliver on-the fly and use test automation
                                                                                                • Monitor KPI and business activities
                                                                                                • Continue with the next innovation cycle containing optimizations and new enhancement

                                                                                                The Appollo Low Code Platform seamlessly integrates into your enterprise architecture

                                                                                                Infrastructure Requirements

                                                                                                For the infrastructure, it is recommended to have one server instance per environment, while the production environment should be redundant.

                                                                                                For development, test and staging environments, we minimally require the following specification:

                                                                                                • CPU:6 Core x 3.6 GHz
                                                                                                • RAM:32 GB
                                                                                                • SSD:2 x 480 GB Software RAID 1

                                                                                                For production environments, we minimally require the following specification:

                                                                                                • CPU:8 Core x 3.6 GHz
                                                                                                • RAM:64 GB
                                                                                                • NVMe2 x 960 GB Software RAID 1

                                                                                                Depending on the needed users and the complexity of the applications, these instances may require to be adjusted over time. 


                                                                                                Appollo = Success Factor

                                                                                                Low Code &

                                                                                                Citizen Development

                                                                                                SUCCESS FACTOR: Roadmap for fast Ramp Up

                                                                                                Low Code & Citizen Development

                                                                                                Appollo Low Code Platform & Citizen Development

                                                                                                Other alternatives are mainly built for professional developers, like Outsystems or Intrexx. Appollo is built for citizen development, while suppporting also professionals. As a success factor we recommend a roadmap of 3 phases, guided by a Center of Excellence.

                                                                                                Center of Excellence

                                                                                                • governance and controlling responsibility
                                                                                                • organizational change management

                                                                                                Phase 1 „Discover“

                                                                                                • Identity a specific Use Case for a Proof of Concept
                                                                                                • Get trained with the Low Code Platform
                                                                                                • Find the right Citizen Developer Team (skills: motivated, business experts, technical interest)

                                                                                                Phase 2 „Evolve“

                                                                                                • Realize Apps for business functions
                                                                                                • make ongoing Assessments and Focus on Quality and risks
                                                                                                • identify and close gaps

                                                                                                Phase 3 „Scale“

                                                                                                • create apps for organization units
                                                                                                • provide rapid implementation
                                                                                                • always innovating, high agility

                                                                                                SUCCESS FACTOR: Skill-based Project Organization

                                                                                                Access Control in Large Scale Projects

                                                                                                Appollo Project Organization & Citizen Development

                                                                                                A very important second success factor is a skill-based project setup which corresponds to the entire application architecture. Use project modularization into subprojects. Subprojects can be used by no-code from parent projects. Give access rights to authorized users according to skills.

                                                                                                User Interface

                                                                                                • use junior citizen developers
                                                                                                • tasks consist of mostly drag&drop, no-code, easily testable

                                                                                                Business Process, Business Rules, Dynamic Case Management

                                                                                                • requires senior citizen developers
                                                                                                • business employees are the perfect candidates as they know their workflows and business rules very well

                                                                                                System Integration and DB layer

                                                                                                • take care to search for expert citizen developers
                                                                                                • already very familiar with the in-depth technical aspects of Appollo

                                                                                                  SUCCESS FACTOR: High Quality by Clean Low Code

                                                                                                  Functionality, Robustness, Security, Maintainability

                                                                                                  Appollo Clean Low Code & Citizen Development

                                                                                                  Third success factor is about Clean Low Code, an important convention of Appollo Low Code Platform and a basis to guarantee high quality. High Quality not only means functional quality, but also robustness, security and maintainability.


                                                                                                  • separate complex functions in submodels as a microservice
                                                                                                  • use a test automation


                                                                                                  • fatal errors or business errors are always handled by no-code
                                                                                                  • you cannot publish a model if those errors aren’t handled


                                                                                                  • developers never know or can log system access data
                                                                                                  • SQL injection is not possible
                                                                                                  • fine grained access rights to publish into runtime environment
                                                                                                  • audit logs


                                                                                                  • models should be easy to read and direct understandable
                                                                                                  • keep models self-contained, small and only use a few lines of code

                                                                                                  SUCCESS FACTOR: Agility

                                                                                                  Issue Management, Kanban Board, Microservices, Runtime Issues

                                                                                                  Appollo Agility & Citizen Development

                                                                                                  Another important success factor is about Agility. There are several features of the Appollo Low Code Platform which help to support agility and high speed delivery in the project and even more.

                                                                                                  Graphical Issue Management

                                                                                                  • Create issues directly at the model and element for a faster understanding

                                                                                                  Runtime Issues

                                                                                                  • End users can create issues directly at the Appollo User Portal and are automatically assigned to the corresponding source element

                                                                                                  Kanban Board

                                                                                                  • manage agile projects using a Kanban board

                                                                                                  Version Management

                                                                                                  • also provides support for branches and hot fixes

                                                                                                  Micro Services Technology

                                                                                                      • easily exchange models on-the-fly for highest availability without downtime
                                                                                                    Contact Us

                                                                                                    3 + 2 =

                                                                                                    Resources & Services

                                                                                                    +49 9371 6692 89-0


                                                                                                    Follow Us

                                                                                                    © 2023 Appollo Systems GmbH