The Livebase Designer neatly guides the analysis process, allowing to efficiently capture requirements as an integrated set of compact, precise and self-consistent diagrams.Learn More
Let Customers watch, while modeling in real-time during the analyis sessions, and keep them involved, attentive, and aware of the sometimes elusive complexity of the application domain.Learn More
Reviewing requirement is tedious and error-prone: let Customers validate them interactively by using generated prototypes, and detect wrong/incomplete specs earlier.Learn More
Analysis & design are critical activities, but it’s hard to measure their progress. Livebase tracks size and complexity of an application Model through its entire life-cycle.Learn More
Livebase narrows the gap betweeen analysis and development. It keeps senior analysts and backend developers on the same page (the Model), minimizing frictions and misunderstandings.Learn More
Any Cloudlet generated by Livebase is also a fully-functional basis for hand-coded extensions (if needed), guiding developers into modular development with a neat pluggable architecture.Learn More
Livebase can rebuild and redeploy a Cloudlet in minutes, when its Model is changed, which means regenerating the Cloudlet’s application and adapting its database schema.Learn More
All the functionality of a Cloudlet (excluding plugins, if any) is entirely described by the Model it was generated from: a set of compact and readable diagrams based on the UML standard.Learn More
By just rebuilding a Cloudlet, developers get a brand-new backend, leveraging the latest technologies supported by Livebase framework and incorporating its improvements.Learn More
Dashboard is a desktop client connected to the Livebase Cloud Services, providing a user interface to control and operate all other components of the Livebase platform.
Designer is a user interface (part of the Dashboard) to capture and visually represent business-level functional requirements by drawing a set of integrated diagrams (Livebase Models).
Library is versioned repository allowing developers to store and share Models within their team. The Library also features metrics, version control, and tools to search and reuse elements of models drawn in the past.
Coder is a code generator translating a Model (drawn with the Designer) into the DDL code to create the Cloudlet database and into the Java code implementing business rules and the GraphQL API.
Builder compiles the code generated by the Coder into a Cloudlet installation package (optionally a Docker container) ready to be transferred to the target hosting infrastructure.
Updater generates the DDL required to update the structure of the Cloudlet database (schema-morphing plan) to make it compatible with the business logic, once it has been regenerated after a Model change.
Deployer connects the Hosting Agent on the target hosting infrastructure and transfers there the installation package generated by the Builder or the database schema-morphing plan generated by the Updater.
Hosting Agent is a lightweight agent that must be installed on a hosting infrastructure to let Livebase deploy Cloudlets there and manage them.
Cloudlets are headless server components generated by Livebase from high-level conceptual Models, without coding. They provide advanced (business-level) transactional data services via a secure GraphQL API.Learn More
Cloudlets natively offer advanced data-management functionality, such as data historicization, virtual data rendering and GraphQL API. They can can also be extended with plugins using many programming languages.Learn More
Cloudlets can be deployed either as normal web applications on a standard and fully open-source software stack, or encapsulated as Docker containers for deployment on a Docker Swarm of Kubernetes infrastructure.Learn More
Unlike most Low-Code development platform, Livebase has been conceived with an open and best-of-breed approach to low-code software development. In fact, no platform can effectively support all the different areas of software development.
We conceived Livebase laser-focused on creating and maintaining transactional data services, which we called Cloudlets , the easiest and most productive way possible, with a few cornerstones in mind: robustness, safety, scalability, interoperability and long-term maintainability.
On the other hand, we made easy and safe to integrate Cloudlets with other backend and frontend components by means of a powerful and self-documenting GraphQL API, allowing developers to use the best technologies and tools for such components, and to leverage the growing ecosystem of GraphQL tools.
According to the Models they are generated from, Cloudlets can incorporate sophisticated data management algorithms (e.g. virtual attributes, objects preview, historicization and deep cloning), transaction validation rules (e.g. objects associability) and role-based access control rules.
Moreover, Cloudlets can be extended with additional logic (plugins) coded in any JVM-compatible language, way safer, maintainable and portable than traditional stored procedures.
With Livebase, developers can:
Any activity performed on the Livebase Dashboard to create and manage Cloudlets can be also performed programmatically by a Jenkins continuous integration/delivery procedure, via a Gradle integration plugin. This allows to generate and deploy Livebase Cloudlets along with other application components in a coordinated fashion, my means of a unique integration/delivery procedure.
Furthermore, Livebase supports Models versioning and allows to deploy the different version of a Model into multiple Cloudlets (e.g. for development, integration, valudation, production, hot-fix) on the same or on different public or private hosting infrastructures.
Cloudlets can provide a structured and enriched view of the data actually stored in the database, and they can enforce sophisticated (business-level) data access and manipulation constraints, generated bug-free from a single conceptual model drawn as UML diagrams. Cloudlets can also execute custom logic coded as java plugins rather than stored procedures.Learn More
GraphQL has many advantages over REST: a single end-point with a query passed as a parameter is way more flexible than hundreds of endpoints with predefined logic, formal schema definition and strong type system (and a growing eco-system of tools and technologies) simplifies and streamlines integration with clients and other backend components,Learn More
Our support covers both STRATEGIC consulting to CIOs (e.g. business processes engineering & automation; audit, migration, consolidation and governance of legacy and shadow-IT applications; etc.) and TECHNICAL coaching to business analysts, information architects, software designers and devops (e.g. modeling specific business requirements, optimizing GraphQL queries and plugin implementations, performance-tuning of hosting infrastructures, etc.)Learn More
Livebase is conceived as a unifying environment for all the professional roles involved in software development, and it's very easy a quick to learn for all of them for one simple reason: it's based on software development concepts, paradigms and technologies very well known and widely used in the industry. However, should you need to speed-up your learning curve with Livebase, we offer a couple of quick courses on data modeling and plugin development.Learn More
Livebase charges developers only for the computational work required to (re)generate their Cloudlets, which depends on the complexity of the Models installed on each Cloudlet. Once generated, Cloudlets run free of charge (unlimited API calls) wherever you choose to deploy them.
Livebase measures the complexity of each Model in LCP (Livebase Complexity Points), a very predictable metric inspired to the Function Point standard. The Livebase Designer shows in real-time the complexity of a Model while it is edited, so that developers have a constant feedback of how much it will cost to generate a Cloudlet from the model they are drawing.
The average complexity of a business application model ranges from hundreds of LCPs (e.g. a simple app for reserving meeting rooms or tracking Christmas gifts) to thousands of LCPs (e.g. implementation of business processes at department level), up to several tens of thousands of LCPs in the case of vertical ERP solutions. Check here some examples of applications built on Livebase and their complexity.
Each Livebase subscription plan provides a given amount of LCPs each month, which developers can use to (re)generate Cloudlets: every time they (re)generate a Cloudlet, the amount of LCPs available in the month is decremented by the LCPs of the Model installed on that Cloudlet.