The Thinkwise Platform is the core of professional DevOps ecosystems in many organizations. But in modern fast-paced development landscapes, it never stands on its own. Integration with specialized third-party DevOps tools is essential for automating DevOps workflows, gaining deeper insights, and expediting deployments.
In this article, we highlight some of the proven DevOps-related tools and integrations that will help you streamline and manage the entire software development and operations process with the Thinkwise Platform. Many of those tools are also used by ourselves, for example for the development of the platform - which is itself a Thinkwise application - and the automated deployment of the ThinkLab environment.
For an overview of integrations to improve and enrich your Thinkwise applications, check out this post.
DevOps Lifecycle
For each of the eight phases of the DevOps Lifecycle, we list the third-party DevOps tools that are either natively integrated in the Thinkwise Platform (linked to and driven from the Thinkwise model) or used in conjunction with the Thinkwise Platform.
Note that, in addition to the tools mentioned, you can integrate virtually any other third-party tool throughout the entire DevOps Lifecycle, as all the information and features of both the Thinkwise Platform and its applications are accessible through the generic Thinkwise Platform API. More information can be found in the documentation on the Indicium OData API and deployment automation.
Plan
Every project starts with the Plan phase, where development teams join forces with stakeholders to define the project goals, gather requirements and set up a development roadmap.
The Thinkwise Platform provides basic integrated Specification & Work Management 🡵. For more advanced features, a variety of tools is available to explore, organize and prioritize ideas, define requirements, and manage and plan work. Commonly used ones are:
- Azure Boards - part of Azure DevOps 🡵
- Asana 🡵
- Atlassian Jira or Trello 🡵
- Productboard - portfolio management 🡵
Develop
With the Thinkwise Platform, development is largely done by visually modeling the distinct parts of your application, like the data model, process flows, and user interface. The platform provides a full-fledged version control system with advanced model-based branching and merging capabilities. Because of the model-driven and declarative nature of the Thinkwise Platform, it is not necessary to use external versioning systems like GitHub or GitLab.
Business logic
For some aspects of your application, like complex business logic and generic concepts (dynamic modeling), it is still needed to write SQL code. Code can be edited with the integrated code editor, but the platform also provides seamless integration with the SQL editor of your choice. Merging code changes in different branches is supported through integration with differencing and merging tools.
Commonly used editors, including some popular plugins, are:
- SQL Server Management Studio - somewhat obsolete in favor of Azure Data Studio 🡵
- Azure Data Studio - lightweight, cross platform data management and development tool with advanced SQL editing features and powerful extensions 🡵
- GitHub Copilot - AI extension
- Visual Studio IntelliCode - AI extension
- Redgate SQL Prompt - code formatting extension
(Thinkwise formatting style by Incentro available here 🡵) - SSMS Keymap - ports SSMS keyboard shortcuts
- Atom One Dark Theme - popular dark theme
- Query History
Supported tools for differencing and merging:
The Thinkwise Platform also provides integration with LLM providers to generate models and code based on natural language descriptions, to analyze and review code, and to generate descriptions of model objects or code templates, for example. Currently, OpenAI and Azure OpenAI are supported 🡵.
Integrations
Developing and testing integrations with third-party applications and services can be challenging. Luckily, there are many API development tools available that can help with this. For example:
Debugging
In addition to the mentioned tools that help you develop and debug code or integrations, the Thinkwise Platform also provides integrated tools that aid in testing and debugging your code or integrations in running Thinkwise applications during development, like the integrated Database Event Log 🡵, Process Flow Monitor 🡵, and Indicium Error Log 🡵.
Build
The Build phase in the DevOps lifecycle focuses on compiling the source code, running automated tests, and preparing the software for deployment. This is where the automation takes off.
In the case of the Thinkwise model-driven development platform, the build phase encompasses the transformation of the Platform Independent Model (PIM), the abstract, technology independent blueprint of the application, to the Platform Specific Model (PSM), that provides the technical details and information to implement the application on a specific platform. This transformation is performed by the Generation definition 🡵 step.
After creating the PSM, the model is then validated by the Validate definition 🡵 step, where the entire model is checked for errors and inconsistencies using a comprehensive set of predefined and custom validation rules.
The source code for the targeted (database) platform is generated based on the PSM during the Generate source code 🡵 step.
Finally, the application can be packaged into a deployment package or, in Development and Test environments, deployed to or upgraded in the corresponding environment, with the Execute source code 🡵 step.
All these steps can be executed manually from within the Thinkwise Software Factory development environment, but the entire build pipeline can also be automated through the Thinkwise Platform API. More information can be found in the documentation 🡵.
Commonly used CI/CD tools to automate the build pipeline are:
These CI/CD tools can often be used throughout the DevOps process, not only in the Build phase. Whether they can provide these features themselves, for example for Release and Deployment, or integrate with other tools, like Test automation.
Test
The Thinkwise Platform provides several integrated features to test your application during different phases of the DevOps lifecycle.
During Development, Unit tests 🡵 and Smoke tests 🡵 can be created and run from the Software Factory. These tests can also be automated by using CI/CD tools mentioned above. Functional testing is supported through the automated Process tests 🡵 (not yet available for the Universal GUI) and manual Test scenarios 🡵.
In addition to the integrated tools, a wide range of third-party tools can also be used for various types of tests. Some examples are listed below.
Functional, regression and API testing
Due to the generic, runtime-interpreted nature of the Thinkwise UI, it is not necessary to test standard OOTB functionality that is provided by the runtime components, like navigation, sorting, filtering, and CRUD functionality. Only customer-specific business logic and interfaces require testing, which can be done using the following tools, for example:
- Cypress - automated UI/integration/e2e testing 🡵
- TestComplete 🡵
- Azure Test Plans - manual testing 🡵
- Selenium 🡵
- BrowserStack - testing on all browsers and mobile devices 🡵
To test the Thinkwise API, for example when calling your application’s endpoints from third-party applications and services, API testing tools can be used like:
- Insomnia
- Postman
Load, performance and stress testing
Reliable performance is crucial for user experience and adoption. With a well-designed application and infrastructure, every Thinkwise application can be blazing fast.
Although performance is something you need to take into account during the development phase of your application, for example by making sure to develop and test with realistic amounts of (anonymized) data, it is always a recommended to do performance or load tests before putting your application in production. Not least to verify that your environment is correctly set up and has sufficient resources to provide the required speed, stability, responsiveness, and resource usage.
Testing performance is generally done best against the Indicium API. Commonly used tools are:
More information on setting up load tests for Thinkwise applications can be found in the documentation 🡵. Note that using Selenium based tools for performance testing is generally not a good idea 🡵.
Release
Thinkwise applications consist of several different components. The Intelligent Application Manager database - holding the application model and the users and roles (RBAC), the application database, the Indicium application tier and the Universal user interface.
The Intelligent Application Manager, Indicium Application Tier and Universal User Interface are usually pre-deployed and do not necessarily change with a new release of your application. More information about the deployment of these generic Thinkwise components in the Deploy phase below.
The application-specific components, defined by the database creation or upgrade scripts and the model synchronization scripts, can be deployed from the Software Factory development environment or manually, but for production environments we recommend using Deployment packages 🡵 instead. Deployment packages offer a way to easily deploy applications created with the Thinkwise Platform to separate locations, customers or tenants.
Deployment packages can be created manually from within the Software Factory or through the platform’s API 🡵. Again, this step can be automated using the build pipeline tools mentioned earlier.
Deploy
The Deploy phase involves the deployment of the Thinkwise Platform and your Thinkwise application to production environments. Key activities include configuring environments, deploying applications, and verifying deployments, in both on-premises or cloud environments. Tools in this phase focus on automation, configuration management, and orchestration.
Configuration management
In addition to the deployment of the Thinkwise Platform and your Thinkwise application, you might also want to manage the configuration of the infrastructure in an automated way, for example when deploying your application to multiple tenants. This is also how we deploy ThinkLab environments to Azure, for instance.
Common configuration management tools that can be used include:
- TerraForm - manages infrastructure as code, allowing for automated provisioning of infrastructure, multi-cloud
- Azure Resource Manager (ARM) Templates and Bicep - define and deploy Azure infrastructure resources
- AWS CloudFormation - offers a way to model and set up Amazon Web Services resources using templates
- Ansible - automates application deployment, configuration management, and continuous delivery
- Chef - manages infrastructure as code, automating the setup and maintenance of servers
- Puppet - automates the delivery and operation of software, ensuring consistency across environments
Intelligent Application Manager
Deployment packages for the Intelligent Application Manager platform components can be downloaded from the Thinkwise Community Portal. They can be executed using the included Thinkwise Deployment Center, either using the graphical user interface (GUI) or the command line interface (CLI). The CLI can also be used together with deployment and release management tools to automate deployments.
While the CI/CD automation tools mentioned earlier can also be used for deployment and (basic) release management, other dedicated tools provide more advanced features to manage complex environments.
- Octopus Deploy 🡵 - dedicated deployment automation tool
Application model and database
The deployment package of your application, created during the Release phase of the DevOps lifecycle, can be deployed in the exact same way as the Software Factory and Intelligent Application Manager.
Indicium and Universal GUI
The runtime components of the Thinkwise Platform, the Indicium Application Tier and Universal User Interface, can also be downloaded from the Thinkwise Community Portal and deployed using the same deployment automation tools. Another, more flexible, option however is to use the provided container images 🡵 that can be downloaded from the Thinkwise Container Registry 🡵. A container image is an application together with all the required dependencies wrapped together into a single image, which can be deployed on many different platforms and updated effortlessly.
Common tools for container deployment and orchestration are, for example:
All major cloud platforms also provide services for running and managing container environments, like Azure Container Apps and Kubernetes Services, AWS App Runner, and Amazon Elastic.
Data migration and ETL
For applications that are modernized using the Thinkwise Upcycler, the Thinkwise Platform provides all the tools to migrate the data from your old application to the Thinkwise application, including any data conversion and transformation required.
For other data migration scenarios, for example for ISVs that need to import data from many different sources, the out-of-the-box import features of the Thinkwise GUI or API can often be used. Staging tables can help to clean-up the data or fix integrity issues.
In cases where the standard import does not suffice, you can use dedicated data migration or ETL (Extract Transform Load) tools that work directly on the Thinkwise database or through the Thinkwise API. Examples are:
Operate
The Operate phase focuses on maintaining and managing applications and infrastructure once they are in production. This includes incident management, performance tuning, capacity planning, and ensuring overall system reliability.
Common tools that are used in this phase are often provided by the used Cloud platforms. For container deployments, Kubernetes also plays a key role in the monitoring, scaling, and management of containerized applications.
Monitor
The Monitor phase is dedicated to the continuous observation of the application and infrastructure performance. This phase ensures that everything runs smoothly, identifies issues, and provides insights for improvements. Key activities include real-time monitoring, logging, alerting, and generating metrics.
Backend
Common tools that are used for monitoring Thinkwise applications and infrastructure are:
- Azure Monitor 🡵
- Application Insights - part of Azure Monitor focused on the performance and user behavior of applications 🡵
- Amazon CloudWatch 🡵
- PRTG 🡵
- Zabbix 🡵
- Nagios 🡵
Database
Database performance monitoring and tuning tools:
- SQL Server Query Store 🡵
- SQL Server Extended Events 🡵
- SolarWinds Database Performance Analyzer 🡵
- Brent Ozar - First Responder Kit 🡵
- Glenn's SQL Server Performance - Diagnostics Queries 🡵
Frontend
Tools focused on the front-end (Universal GUI):
- Sentry - application performance monitoring & error tracking, integrated in the Thinkwise Universal GUI 🡵
- Miruni - submit and resolve visual feedback, bugs, and ideas 🡵
Which ones to choose?
The tools listed in this post are examples of tools that we have more or less experience with at Thinkwise, but there are many, many more. And because the Thinkwise Platform only uses mainstream technologies, provides an extensive API and supports many different platforms, you are virtually unlimited in the choice of which ones to use.
All tools have advantages and disadvantages, also depending on your unique situation and requirements, so you’ll have to decide for yourself which ones suit best. Need any advice? Then please don’t hesitate to contact your Thinkwise contact person.
