Let’s Model Architecture

Let’s Model is a robust enterprise class Model Driven Development -MDD solution. The Let’s Model Enterprise Application Platform delivers your (mobile) app as web services based on a data model, business logic and roles & permissions.

Develop Enterprise Apps in hours instead of months Changes in data model and business rules will be implemented immediately.

Let's Model Tech Diagram

Let’s Model is MDD 2.0

With Let’s Model Enterprise Application Platform you still have the traditional 3 tier environment. In the core we produce the same 3 tiers but we differentiate by our unique approach.

The Let’s Model platform automates all programming tasks reducing errors and bugs to zero. Changes to your business rules or your information model are implemented automatically.

Let's Model InterpretersLet’s Model uses the MDD 2.0 Requirements Definition to guaranties a 100% fit of all tiers. The Let’s Model MDD 2.0 Builder creates the MDD2.0 Requirements Definition automatically from three requirement types: your Business Information Model, Roles and Permissions and Application Behavior. This single definition is used by the Let’s Model interpreters to automatically build your RESTful Middle Tier and to build your Presentation Tier. 

The Let’s Model MDD 2.0 Builder

The Let’s Model MDD 2.0 Builder automatically creates the MDD 2.0 Requirement Definition from the following three requirement types:

  • Your Business Information Model
  • Your Roles and Permissions
  • Your Application Behavior

The Roles and Permissions and the Application Behavior can be entered into the MDD 2.0 Builder and will then be applied to  the whole application at once. Roles and Permissions are defined to be able to implement role based function separation and overall application security. Within the Application Behavior you have the freedom to specify how application will behave based on over 50 different domains / control types.

Agile Development the Proper Way

The MDD 2.0 Builder features two major principles.

Convention over Configuration

The Let’s Model Builder will select the most logical configuration for you by convention. If you want to configure instead of the convention, you can configure on multiple levels. Either start from the highest level or overwrite on a very detailed level.


The build-in inheritance of configuration minimizes manual efforts and possible mistakes. Even when your Business Information Model changes, Let’s Model will make it work for you. No miss-matches. No impact analysis and code changes necessary any more. Building applications with the Let’s Model Enterprise Application Platform is done the Agile way.

Completely DRY

Development of applications with Let’s Model is completely DRY over all tiers. The MDD 2.0 Requirement Definition build with the Let’s Model MDD 2.0 Builder is used to create the Middle Tier and the Presentation Tier. This way there is only one repository where the automatically build Requirements Definition is stored. The Let’s Model platform does the rest.

Separation between WHAT and HOW

In the Let’s Model way of developing, functional requirements are abstracted from technology (instead of imprisoned). In the three sub-systems (Business Information Model, Roles & Permissions and Application Behavior) the WHAT is defined. These are functional requirements. The Let’s Model platform takes care of the HOW. This is the technological implementation of the functional requirements. Separating WHAT and HOW prevents interpretation errors between Business and IT, but also between the various Tiers and their Guru’s.

RESTful Middle tier

Let's Model Middle Tier

RESTful Web Services

The Let’s Model Platform delivers standard Web Services following the RESTful approach. This means that the interface is easy to understand for development (if any at all). WIth the Let’s Model RESTful Web Services it is extremely easy to build Enterprise iOS and Android applications.

WQL Statements

Let’s Model uses its Web Query Language (or WQL). WQL is RESTful and as simple as SQL. Interactions between clients (iOS, Android or Browers) and the Web Service are done  over HTTP/HTTPS in WQL statements. The Let’s Model platform translates these requests into SQL statements, eliminating SQL injection threads completely. Another benefit from the WQL to SQL translation is that the authorization of the statements automatically enforces intrusion detection.

Auditing and Journaling

All transactions and procedure calls in Let’s Model are fully audited. This means that your compliance requirements with the Let’s Model Enterprise Platform are fully met. The Let’s Model auditing provides a complete overview of who has done what transaction when with your valuable company data.


Clever Web Service response caching mechanisms and cache management prevent unnecessary database loads and cause fast roundtrips of less than 4 milliseconds. It is not only your database that benefits but also your Middle Tier resources. Web Service response cache delivers not only higher performances from your Middle Tier but also lower bandwidth usage in your data center. The response cache is automatically version controlled by Let’s Model.

Scale Up, Scale Out

Since Let’s Model has a database centic architecture, is scales the same as you database. Let’s Model platform also fully supports Content Delivery Networks (CDN) to be able to scale out.

Freedom in the Presentation Tier

Let's ModelGUI

With the Let’s Model platform you have the freedom to create any Presentation Tier you need. Whether you need a GUI on iOS, Andoroid, Browser or Flash, Let’s Model delivers. If you want you can develop your own native user interface by talking directly to the Let’s Model RESTful Web Services. Or you can choose to extend the benefits of the Let’s Model platform by using the Let’s Model Presentation Tier Generic HTML Snippet Generator. You can then use the standard Let’s Model Web GUI or build your own HTML Web GUI.


With the Let’s Model Enterprise Application Platform you do not need to do any coding for your generic web GUI. The HTML Snippet Generator can be used in your custom Web GUI to greatly reduce the need for coding yet providing you with great flexibility.

Support over 50 Domains

The Presentation Tier of the Let’s Model platform supports over 50 domains resulting in a rich user experience. The domains are declaratively assigned to your Business Information Model. The Let’s Model platform takes care of the automatic implementation of the different domains.

Automatic Caching

With the version controlled server response cache the Let’s Model platform uses 304 status codes to prevent the Middle Tier from unnecessary sending the message body. This way Let’s Model is able to provide real-time responses with minimal bandwidth usage.

Lazy Loading Application Logic

Let’s Model only loads that part of the application that is needed just in time on a need-to-know, need-to-show basis. By nature you do not have to implement any application updates at the client anymore. Application updates are automatically deployed on your clients. Partly application loading also preserves bandwidth.

Open Web Standards

The Let’s Model Enterprise Application Platform is completely based on open Web standards. This makes it possible for you to fully customize the out-of-the-box Web GUI as well as your own custom developed User Interface.

download Let's Model