Thinkwise Platform Overview
This document provides a high-level overview of the Thinkwise Platform, comprising the Software Factory development environment, the Intelligent Application Manager, the Indicium Application Tier, and the various adaptive user interfaces.
Introduction
The Thinkwise Platform is an integrated software development environment to develop new software applications and modernize existing applications. These applications consist of a database, business logic, service tier, user interfaces, and, if necessary, data interfaces to other applications.
Applications developed with the Thinkwise Platform environment are easily kept up-to-date both technologically and functionally. The productivity of the development process amounts to 0.5 hours per function point. Currently, the market average for traditional software development is 8 to 10 hours per function point, and the market average for other low-code platforms is approximately 2.5 hours per function point (see 6.3).
For a first impression, watch the Thinkwise Platform introduction in 4 minutes (opens in a new tab).
Thinkwise Platform components
The Thinkwise Platform consists of the following components:
- Software Factory
- Intelligent Application Manager (IAM)
- User Interfaces
- Indicium Application Tier
- Upcycler
The positioning of the various Thinkwise components is presented in the diagram below. The components that are included in the Thinkwise Platform are shown in blue. The green components are created by the developer or application manager using the Thinkwise Platform, while the parts in gray are created automatically by the Thinkwise Platform.
Thinkwise Platform overview
The Software Factory is used during the development and test phase to develop an application on the basis of a model (blueprint). The user interfaces interpret the model during runtime so that the user can work directly with the application. Once the development is completed, the model is transferred to the Intelligent Application Manager in the production environment.
The Intelligent Application Manager manages all the models of applications that are in the acceptance and production phases. The application managers can also set up authorizations using IAM. The presentation for the user is again provided by the user interfaces. End users can set up their own user preferences via the user interfaces and get suggestions from IAM to optimize their user experience.
User interfaces are available for the most common devices (desktop/laptop (Windows), web, smartphone, and tablet). The capabilities of the Thinkwise user interfaces (Universal UI or Windows UI) are very extensive and nearly identical, as far as is technologically possible.
The Thinkwise Indicium Application Tier is the central integration hub of the Thinkwise Platform. It provides secure access to the data, processes, and business logic of Thinkwise applications through an open REST API.
The modernization of software applications takes place with the Thinkwise Upcycler.
Each product is discussed separately in the following chapters.
Extensive online documentation is available for the Software Factory, Intelligent Application Manager, user interfaces and Indicium Application Tier. The requirements for their installation are also described in the documentation.
In the Software Factory, links to the online documentation and the Community are available in the Developer tab in the ribbon.
Direct access to the documentation and Community
Example
This is an example of a legacy application that is modernized to a Windows application using the Thinkwise Platform.
The legacy screen:
Example of a legacy application
The modernized screen:
Example of a modernized application
Application architecture
Thinkwise applications consist of a data tier, an application tier (Indicium Application Tier), and a presentation tier (user interfaces).
In addition to the Thinkwise user interfaces, it is also possible to connect custom-built or third-party user interfaces or applications to the Thinkwise API to access the data, processes, and business logic of Thinkwise applications.
The business logic containing customer-specific functionality is included in the data tier in the form of SQL procedures. Through the Thinkwise Application Tier, it is also possible to connect external services to integrate external or custom-built business logic in a wide range of programming languages and protocols.
For possible configurations of the platform's infrastructure, see Reference architecture.
Thinkwise Application Architecture
Software Factory
The process of development with the Software Factory consists of the following phases:
- Specification
- Modeling
- Data
- User Interface
- Processes
- Business Logic
- Quality control
- Access control
- Deployment
This is presented in the figure below:
Development in multiple phases
These phases correspond to the menu in the Software Factory development environment. The development team has access to the components of these phases via the menu on the left-hand side of the screen.
Specification
Business processes can be defined in the Software Factory to gain a deeper understanding of the scope and context of the application(s) that will be built.
Requirements can be seen as a contract between the business and the developers, with which the scope of the project is continuously monitored.
Work items are created for requirements to guide the developers during the development phase.
Business processes
During the analysis phase, the function flow diagrams are designed first. The relationship between a business process and the functional entities, such as departments, are specified there. These functional entities are displayed on the horizontal strips. The function flow diagrams are often designed based on interviews with the interested parties of the project.
Other elicitation methods can be applied, such as analysis of the existing application, documentation, observation of end users, etc.
Example of a function flow diagram
Requirements
The user and system requirements are subsequently specified for each process. Using the integrated stakeholder portal, stakeholders can review and comment on flow diagrams and requirements before accepting.
Example of a requirement
Features and iterations
Requirements and work items can be organized using features and iterations. Features can help categorize the work more efficiently while iterations facilitate the planning process. Features and iterations can be configured completely to your wishes, for example, using applications, modules and sub-modules to group features or by using releases and sprints as iterations.
Work and taskboard
Development teams can use work items to describe, plan, and keep track of development activities. A work item describes what changes to a model or business logic need to be done. The taskboard allows developers to keep track of and update the status of their work.
Work on the taskboard
Modeling and Validation
During the modeling phase, the following models are specified:
- Data
- Enrichment
- User Interface
- Menus
- Screen types
- Subjects
- Business intelligence
- Maps
- Themes
- Messages
- Translations
- Icons
- Help
- Processes
All these components form the basis for the application without it being necessary to have to program them. Only the model has to be created. This takes place based on the requirements and work as drawn up in the previous phase.
The quality of the model is monitored with validations. Thinkwise provides hundreds of validation rules, but company-specific validation rules can also be added.
Example validation rules
When the model is created, a demonstration can be given to the business to show at an early stage what the application will look like and how it will work. This demonstration helps build a bridge between the business and IT.
Data model
The database of the application is designed using the data model, which is presented graphically, as shown in the figure below. The same table can be displayed in different ways by creating variants. You can use a variant, for example, to optimize a table for a specific platform.
Example of a graphical data model in the Software Factory
Enrichment
Different ways of enriching your model are available in the Software Factory. They facilitate and speed up the development of your application.
-
Model enrichment is the process of automating parts of your manual workflows. The Software Factory comes with a large number of ready-made enrichments that are also available as tasks in the screens where they are most relevant, but you can also create your own.
There are three types of enrichments:
- A model-driven enrichment can be used to check, for example, the consistency in your application. You can re-run it on a need-to basis.
- A data-driven enrichment will prompt you for a runtime configuration when you start it. It queries the database to load the information required to present the model updates. Examples of this type of enrichment include generating missing indexes, creating mock data based on table content, and deriving control types and elements from data in the database.
- An AI-powered enrichment will use the configured generative AI provider of the Software Factory to retrieve information from a large language model. Examples include generating descriptions, translations, comments, etc.
-
The ThinkStore in the Software Factory is a fully integrated way for downloading and installing ready-made solutions directly into your models. It contains an extensive collection of free scripts and samples created by Thinkwise developers to help you get the most out of the Thinkwise Platform.
Example of a ready-made solution in the ThinkStore -
If the solution you need cannot be created in the Software Factory and is not available in the ThinkStore, you can extend your model with dynamic modeling. This means including meta control procedures in the generation process to improve your model. Data modeling especially concerns your data model and user interfaces model that form a main theme throughout the application.
The following are examples of data modeling:
- Adding trace columns (added on/by, changed on/by) to all tables and display on a separate tab in the user interfaces.
- Add an update counter column to tables that are updated.
- Create indices on standard forms of the user interfaces
As soon as a meta procedure is added, the aspect is automatically added and requires no more maintenance if the model is modified or extended. SQL code must be programmed once for each metaprocedure and requires knowledge of the Software Factory metadata and its concepts.
User Interface
The user interface is also designed without programming. The design is flexible so that screens automatically adjust themselves to the various resolutions. By linking (self-designed) screen types to the subjects of your model, a user interface can quickly be developed for hundreds of objects.
The user interface is multilingual and contains possibilities for integrated Business Intelligence (pivot tables and graphs). In addition, graphical plans and geographic presentations are easy to integrate.
Modeling a screen type
Business Intelligence
The Thinkwise user interfaces include integrated Business Intelligence functionality for presenting interactive pivot tables and graphs that make operational management information available. It is also possible to connect with Microsoft OLAP (SQL Server Analysis Services).
Example of integrated charts
Help
Help texts can also be defined in the Software Factory for each process and object. The help text can be set up fully multilingual. The user interfaces are context-sensitive and immediately show the relevant part of the help text.
Example of the help text
Process flows
End users are automatically guided through the application with the help of process flows, where the subsequent process steps that must be acted upon are presented to them. System flows are process flows that do not require user input. They can contain reusable subflows. Process flows are designed graphically, as seen below.
Example of a process flow
Scheduling process flows allows applications to operate autonomously in the background without user interaction.
Tasks
Batch tasks or interactive tasks can be modeled, for example, to execute a calculation or generate invoices. These tasks can be started automatically by a scheduler or manually via the user interfaces. Interactive tasks can request input from the user before they start.
Example of a task pop-up
Reports
For the generation of reports, a process flow can be configured, and a connection can be made to various reporting tools, such as DevExpress Reports, Crystal Reports, Microsoft Word, SQL Server Reports, and i-net Clear Reports. These reports can be viewed, printed, mailed, and exported to various formats automatically or via the user interfaces.
Customizing reports is possible with a parameter property in the Software Factory or by overriding the default report file in IAM.
Third-party integration
The Thinkwise Platform offers a wide range of integration options, allowing you to connect your application to virtually any third-party application, tool or service.
In many cases, out-of-the-box integrations are available, such as components, controls, and connectors. For all other integration needs, the platform provides generic connectors that allow you to connect to web services or APIs, databases, cloud services, and more.
Artificial intelligence
The Software Factory facilitates using Artificial Intelligence (AI) to support and improve your business processes.
- You can train and deploy Machine Learning models (AutoML) to predict information, such as prices, costs, or risks. Advanced algorithms are automatically selected and trained to be able to make predictions. You feed the data, and the AutoML service will do the rest. No prior knowledge of statistics and machine learning is required.
- Large Language Models (LLMs) are trained to transform or predict text. Use these, for example, to summarize texts, set up a chat, or find related tickets. The Software Factory contains process actions with integrated LLMs that you can use in process flows.
- A large number of AI-powered enrichments and tasks is available to facilitate and speed up your development process. You can also create your own AI-powered enrichments.
Development and testing
The last phase of the project consists of programming and testing the business logic.
Development
Code templates are written according to the design specifications. This is the only component that is actually programmed. Templates are woven into the correct position in the business logic layer, based on the definitions in the model.
Architecture of the programmed business logic
Testing
The programmed templates can be tested automatically with unit tests. Smoke tests and process tests are available to test business rules/code. Manual testing is supported through manual test administration. All tests are stored in the Software Factory.
With the integrated test tooling, a test only needs to be specified once and can thereafter be executed automatically. This guarantees that existing functionality continues to work after additions and modifications.
-
Unit tests can be used to test individual business rules. Any data that is required for a unit test (mock data) can be specified as part of the unit test.
-
Smoke tests are preliminary tests to reveal simple failures severe enough to, for example, reject an upcoming software release. In the Software Factory, these are available to ensure a basic quality level of SQL queries in your application.
-
Manual tests can be used to set up manual test scenarios with steps and test them in runs. Problems found can be documented in test findings.
-
Process tests are used to test processes in the context of a user. Process tests can be created in three ways:
- Recorded via the user interfaces.
- Modelled via the Software Factory.
- Automatically derived from the existing model.
Process tests are executed by the user interfaces, and the test results are stored in the Software Factory.
Recording test cases via the user interface
The test results are also analyzed there.
Analysis of the test results
Developer tools
Along with the development tools, Thinkwise also offers tools to analyze the model and convert it to an actual application. These tools can be found under the Models, Deployment, and Analysis menus.
Development management
The continued development of the model of an application takes place in the Software Factory through the use of models and branches. By performing a difference analysis, it is automatically determined what must be modified in the database and business logic. The data in the database is retained and will automatically be converted to the new structure.
DTAP
Usually a DTAP street is used during development. DTAP stands for the Development - Test - Acceptance - Production process which every version must pass. By working in branches and utilizing Runtime configurations, the Thinkwise Platform is extremely suitable for this.
Deployment automation (CI/CD)
Since all the creation and deployment jobs are performed by the Indicium Application Tier, it is possible to automate your entire deployment process. Automation will support the CI/CD automation processes in your organization. It allows you to update and test your application in the development environment, update acceptance environments, and prepare deployment packages to roll out to your production environments.
Working in teams
A model for an application can be split into one or more branches. This allows different teams and team members to work on the same application (within their own branch) without getting in each other's way.
Finally, the modifications and expansions of a branch are combined (merged). Conflicts can possibly occur during merging, but these are automatically detected by the Thinkwise Platform and presented to the developer.
Example of branching and merging
Quality control
The Quality Dashboard provides an overview of the quality of all models in the Software Factory.
The model quality is calculated based on:
- Model quality: the amount of validations with unsolved messages.
- Code quality: the control procedures that are in development and review per developer, the overall code reduction ratio, and the ratio comment/code.
- Test quality: the amount and success of unit tests and smoke tests.
- Role quality: how well roles are used.
Example of a Quality dashboard
Intelligent Application Manager
Through the Intelligent Application Manager, applications are provided with authentication, authorization, user administration, and user preferences in a simple and well-organized manner.
Users get one user interface with which they can obtain access to all applications to which they are authorized. These applications can even be located on different servers and RDBMSs.
The Intelligent Application Manager has the following components:
Synchronization
To make a new or existing branch available as an application in IAM, you need to synchronize it with the Software Factory. This means that the blueprint is copied from the Software Factory to IAM. Next, the authorization for this application can be set up via IAM.
Authorization and multi-tenancy
Authorization is linked to roles and user groups using Role Based Access Control. A user group contains several users, but a user may also be a member of several user groups. If required, membership is time-related, so access rights automatically expire after some time (for example, with temporary contracts). Authorization can be defined down to field level and on cross-sections of data.
Which data is accessible to an end user depends on the configuration of various actors and settings. To ensure all actors and settings are aligned, IAM offers security checks to assert the correct configuration.
In some scenarios, multi-tenancy can be a suitable solution for your organization. Tenants are isolated environments where administrators can work solely with their own users and user groups. Every user and user group can be a member of a single tenant. For Independent Software Vendors (ISVs), the term 'tenant' in a SaaS environment can usually be exchanged with 'customer'.
Authentication
Users and external parties can be authenticated via Personal Access Tokens (PATs), Client applications, Single Sign-on (OpenID), IAM authentication, or the RDBMS.
Two-factor authentication using e-mail, SMS, or TOTP can be used as an extra layer of protection.
User preferences
In addition, it is possible to set user preferences. These preferences are automatically stored when a user makes changes to the interface. For example, splitter positions can be retained, column positions modified, and even entire screen types can be changed.
Everything a user can do with regard to user preferences can be authorized.
Self-learning
IAM can analyze each user's way of working and provide suggestions to optimize the user experience. As an administrator, you can decide to apply each recommendation or not.
If a user frequently opens the customer screen and then filters on a customer, IAM can recommend opening the customer screen with the application. This will not immediately retrieve the customer details from the database but first show the filter screen. This leads to fewer user actions and a lower load for the server.
The analysis can also be a reason to provide the user with additional training.
Simulation to provide support
Because the user interfaces can differ for each user through authorization and user preferences, support employees can start an application using the settings and authorization of a specific user. This way, the support desk employee sees the same user interfaces and user preferences, and can provide better support to the user.
Logging and monitoring
Logging is available in IAM for the multiple purposes, such as:
- Authorization - All changes related to authorization are logged automatically. This helps maintain SOx compliance and meet important control guidelines.
- User monitoring - Logs are available for session analysis (for individual users or all users), two-factor authentication analysis (for individual users or all users), and OpenID analysis.
- Environment interaction monitoring - Environment interaction logs are available in 3-tier production environments. These logs help detect malfunctioning external services, disks and printers, application connectivity issues, and provider misconfigurations.
Maintenance
Several types of system flows for maintenance can be scheduled to run automatically:
- For IAM maintenance, such as data cleanup or sending email notifications.
- For IAM, the Software Factory, and your applications to improve SQL Server performance when many indexes are fragmented, or statistics are outdated.
User Interfaces
The Thinkwise user interfaces are available in various technologies. Separately for desktops, web, and mobile devices, or combined into one progressive user interface for all platforms. Thinkwise ensures that the user interfaces are available for future technologies so your applications automatically remain up-to-date.
A user interface does not need to be programmed. It is completely built during runtime on the basis of:
- Model
- contains the definition of the user interfaces.
- is defined in the Software Factory and synchronized with IAM.
- Authorization
- omits everything for which a user is not authorized.
- is defined in IAM.
- Theme
- consists of a color scheme, logos, etc., and can, for example, differ for users of a customer in a customer portal.
- is defined in the Software Factory and selected in IAM.
- User preferences
- provide an individual display of what a user is authorized for.
- are provided by the user interface and recorded in IAM.
The user interfaces are fully multilingual and communicate with the same business logic layer.
A summary of the functionality for each type of user interface is given below. A comprehensive description is given in the various manuals. The screen examples come from the Insights application that is used by Thinkwise for training purposes.
Universal GUI
The Thinkwise Universal user interface provides an ultra-modern user experience on mobile devices, desktops, and the web. It has been designed, along with the Indicium service tier, with an emphasis on performance, security, and user experience.
This user interface is a Progressive Web App (PWA), built using React and following the Material Design guidelines, a comprehensive guide for visual, motion, and interaction design across platforms.
Example screen of the Universal user interface on a tablet
The Universal user interface offers a wide range of default functionality, available through button bars and overflow menus. Data can be visualized in hierarchically structured screens with multiple subjects using grids, forms, maps, schedulers, charts and pivot tables, document previews, dashboards, and more.
The main advantage of the Universal user interface over other Thinkwise interfaces is that it is a fully responsive Web App running on any device. It automatically adapts to the device's characteristics, such as the screen size and input method. The Universal user interface is deployed as a web application but, being a Progressive Web App, can be easily installed onto the user's device like a native desktop or mobile app. It can use native device features, such as camera and location services.
Example screen of the Universal user interface on a smartphone in a light and dark theme
Windows GUI
The Windows user interface provides a wide range of default functionality, available through the integrated ribbon, button bars, and the context menu.
Data can be visualized in hierarchically structured screens with multiple subjects, using grids, forms, maps, charts and pivot tables, document previews, dashboards, Gantt charts, and more.
The user interface supports different reporting options and import, export, and mass update of Excel and CSV files.
Data can be added, updated, and deleted using forms, inline editing in grids, and task popups.
Individual fields can be displayed and edited using regular text- and numeric controls, calculators, calendars, checkboxes, links, barcodes, rich text and HTML controls, progress bars, radio buttons, and more.
Extensive search and filter options are available using predefined filters, column header filtering, a powerful search box, and an advanced filter pop-up to create complex filter conditions.
The user interface also supports drag-drop of rows and files, clipboard actions, window docking, and multiple windows.
Example screen of the Windows user interface
Deployment
The Windows user interface can be deployed centrally with the help of the Thinkwise Deployment Center. If the user interface is started on a desktop, it is first checked whether a newer version is available centrally. If this is the case, then this version is copied to the client and only then started up.
A new version is only required if Thinkwise has expanded the standard user interface functionality and not if the application itself has been modified. This takes place via the model.
The Windows user interface can also be run under Citrix, Terminal Server, and VDI.
Tablet
An example of a tablet display is given below:
Example screen of the tablet user interface
Smartphone
An example of a smartphone display is given below:
Example screen of the smartphone user interface
Indicium Application Tier
The Thinkwise Indicium Application Tier is the central integration hub of the Thinkwise Platform.
It provides secure access to the data, processes, and business logic of Thinkwise applications through an open REST API.
Two types of the Indicium Application Tier are available:
- Indicium: for use with the Universal GUI and via API's. This version uses the full range of Indicium functionality.
- Indicium Basic: for use with the Windows GUI. This basic version does not support, for example, system flows and OpenID.
Thinkwise Indicium Application Tier
Connectivity
The Thinkwise Indicium Application Tier provides a solution for all integration challenges. With automated processes and a range of default connectors, the Thinkwise Platform can connect to a wide range of third-party services and applications, like:
- Artificial Intelligence services (Bots, Virtual Assistants, Machine Learning, Image recognition)
- Big Data solutions (Search, Analytics, Internet of Things)
- Office integration (Exchange, Office 365, SharePoint)
- Third-party applications (custom user interfaces, financial applications, Power BI)
Third-party applications and services, in turn, can connect to Thinkwise applications with minimal effort using the provided webhooks and REST API. The Thinkwise Application Tier uses the OData protocol for its API, one of the most widely used standards for RESTful web services.
Here are a few examples:
Exchange Connector
Thinkwise applications can synchronize appointments, tasks, e-mails, and contacts with Exchange.
The Thinkwise Exchange connector
Incoming and outgoing e-mails can be enriched in the application so that the exchange with a customer or supplier is fully and quickly transparent. Appointments and tasks can be made in the application, then dealt with in Outlook, whereupon any changes are passed on to the application.
Business Intelligence can then be applied to e-mails, appointments, and tasks.
Web services
SOAP and JSON/REST services can be called, for instance, to retrieve distances, postal codes, and CoC details. Furthermore, all data, processes, and business logic of Thinkwise applications is available through web services and can be used by other applications and services.
Maps
The user interfaces can visualize geographic data such as locations and routes on maps from various providers, such as Google Maps, MapQuest, and Here Maps.
Example of maps integration
Security
The Thinkwise Platform is designed with security in mind, following the Security by Design principles. It provides controls to protect the confidentiality and integrity of information and to ensure availability to authorized users. The Thinkwise Platform supports different authentication protocols, like Personal Access Tokens (PATs), Single Sign-on (OpenID and ADFS), Client applications, and multi-factor authentication.
The Thinkwise Intelligent Application Manager provides role-based access control and entity-, row- and field-level authorization, while the Application Tier ensures that business rules are respected at all times, even when bulk importing data or when interfacing with third-party applications.
Scalability
The Thinkwise Platform is optimized for speed and scalability. The stateless Application Tier can easily be horizontally scaled for load balancing and failover purposes. This allows optimal use of the power of cloud platforms, such as Microsoft Azure, Amazon Web Services, Google Cloud, or IBM Cloud.
The Application Tier is developed with the .NET Core framework, making it cross-platform and highly optimized for running in (Docker) containers.
Upcycler
With the Thinkwise Upcycler, a model can be derived from your existing legacy application and imported into the Software Factory. Depending on the legacy technology and the available metadata, the derived model already contains tables, columns, domains, controls, references, translations, screen types, and more.
The Upcycler will also determine which parts of the legacy software are not used anymore and eliminate those parts automatically. Next to that, the remaining model can be enriched by analyzing the data combined with the best practices of Thinkwise.
If your legacy software didn't enforce referential integrity, there may be inconsistencies in your data. The Upcycler will automatically detect any data inconsistencies, so these issues can be resolved immediately.
Because the data model has been derived from your legacy software, the Thinkwise Software Factory is able to automatically transform and import the data from your legacy application into your new Thinkwise application.
The Upcycler supports the modernization of more than 30 legacy technologies.
Appendices
The appendices consist of the following components:
- A selection of reference customers that have purchased an application that is built with the Thinkwise Platform or have purchased a license for the Thinkwise Platform.
- An overview of the measured productivity.
References
The following companies are some of our references. On our website you will find an extensive list of our customers.
Productivity
Function Point Analysis
Function Point Analysis (FPA) is a method to measure the functional scope of an information system. FPA measures this functional scope by examining the functions and (logical) data collections that are relevant for users. The measurement unit is the function point (fp), and so the scope of a system is expressed in number of function points.
Function points are a good measure of the size of a system. The function point measurement unit can be used in several ways. An often-used application of FPA is the estimation of system development. The costs of developing a system are related to its size. The larger the system, the more expensive it will be. FPA canbe used both for new development and for maintenance projects.
From previous experiences, it is known how many hours on average are needed to develop one function point. This defines the productivity. Size (number offunction points) x productivity (required hours per function point) provides a basis for the project budget.
FPA is a objective method that does not require IT knowledge. With sufficient documentation, an FPA count for a system of 1000 development hours can be made in approximately 1 hour.
| Programming language | Hours per function point |
|---|---|
| Java | 10.6 |
| C# | 15.5 |
| SQL | 10.8 |
| ABAP | 19.9 |
| Other low-code platforms | 2.5 |
Market average for each technology
The Software Factory automatically counts the function points of an application. This point count is officially calibrated by the QSM authority. In addition, Thinkwise is a member of NESMA (Dutch Software Metrics Users Association).
| Thinkwise Customer | Hours per function point | Function points |
|---|---|---|
| Combifloat | 0.25 | 5536 |
| Foresight | 0.10 | 8938 |
| Laura Metaal | 0.14 | 15306 |
| Manter | 0.55 | 4604 |
| Paul Meijering | 0.26 | 14318 |
| Staay Food Group | 0.63 | 13144 |
| VDL | 0.56 | 22563 |
| WEC Lines | 0.31 | 6730 |
Function Point measurements of Thinkwise projects. The time spent in hours includes the design, development and test phase of the applications. The mentioned function points are based on one user interface technology only.