Einleitung

Automatisierung von Geschäftsprozessen ist ein entscheidender Faktor, um im Wettbewerb zu bestehen. Low-Code-Entwicklung ist eine spannende Möglichkeit, um fehlende Entwicklungsressourcen auszugleichen und Geschwindigkeit bei der Digitalisierung aufzunehmen. In diesem Blogbeitrag beleuchten wir die Herausforderungen sowie Lösungsansätze, die bei der Umsetzung von Low-Code-Projekten auftreten können.

Ein kurzer Überblick

Low-Code-Prozessautomatisierung ermöglicht es Experten, Projekte schnell und effizient umzusetzen, indem sie sie dabei unterstützt,

• visuelle Entwicklungswerkzeuge und vorgefertigte Komponenten zu nutzen, um Anwendungen mit wenig oder keinem Programmieraufwand zu erstellen;
• auf bestehenden Integrationen, Bausteinen oder anderen Artefakten aufzubauen, um die Entwicklung zu beschleunigen und die Komplexität zu reduzieren;
• eine Vielzahl von Artefakten wie Formulare, Prozesse, Entscheidungstabellen, Dokumentvorlagen oder E-Mail-Templates für die Automatisierung zu erstellen.

Zahlreiche Softwarehersteller haben integrierte Web-Plattformen mit dem Versprechen bereitgestellt, vollständig auf klassische Softwareentwicklung verzichten zu können. Wenn dann aber doch irgendwann stärkere Anpassungen notwendig sind, ist der Einsatz der klassischen Softwareentwicklung häufig nicht oder nur mithilfe proprietärer Sprachen möglich.

Bei der Entwicklung von Automatisierungslösungen mit Low-Code Plattformen treten häufig Herausforderungen auf. Diese werden verstärkt, je mehr Systemintegrationen in einem Prozess verwendet werden oder je mehr unterschiedliche Tools benötigt werden.

Herausforderungen bei der Umsetzung

Bei der Entwicklung und Umsetzung von Low-Code-Projekten können verschiedene Herausforderungen auftreten:

• Management von Artefakten und Abhängigkeiten: Die Vielzahl von Artefakten und deren Abhängigkeiten untereinander müssen zur Laufzeit berücksichtigt werden. Dies erfordert ein effektives Dependency Management und Versionskontrolle. Häufig werden unterschiedliche Low-Code-Tools eingesetzt; Deployments in spezifische Umgebungen müssen daher organisatorisch gelöst werden, weil jedes Tool seine eigene Projektverwaltung inkl. individuellem Deploymentprozess mit sich bringt.
• Fehlerbehebung und Migrationen: Fehler in laufenden Prozessen müssen identifiziert und behoben werden. Dabei ist es wichtig, Migrationen durchzuführen, um sicherzustellen, dass alle Prozesse und Artefakte auf dem neuesten Stand sind. Die Anpassungen müssen dann zusätzlich auf den aktuellsten Entwicklungsstand und in unterschiedlichen Tools angewendet werden - der sichere Weg in die “Versionshölle”.
• Nachvollziehbarkeit: Den Überblick der verschiedenen Prozessversionen und ihrer Abhängigkeiten in unterschiedlichen Systemen zu behalten kann komplex sein, insbesondere wenn es um die Verwaltung verschiedener Versionen von Artefakten und Integrationen geht. Wann wurde welche Version in welcher Umgebung ausgebracht?
• Impact-Analysen und Vulnerability-Checks: Es ist wichtig, mögliche Auswirkungen von Systemausfällen oder Sicherheitslücken auf die entwickelten Prozesse zu untersuchen und entsprechende Gegenmaßnahmen zu treffen. Was passiert, wenn Schnittstellen geändert werden? Welche Prozesse oder Formulare sind von Fehlerbehebungen und Schwachstellen betroffen?

Lösungsansätze

Um die Herausforderungen bei der Umsetzung von Low-Code-Projekten zu bewältigen, können folgende Lösungsansätze hilfreich sein:

• Projektverwaltung inkl. Berechtigungen: Git-Repositories ermöglichen ein effizientes Management von Projekten, einschließlich der Zugriffsrechte für verschiedene Teammitglieder. Zudem können Entwicklungsstände einzelner Artefakte gemeinsam versioniert werden.
• Versionskontrolle: Auch hier bietet Git mithilfe von Branches und Tags einfache Möglichkeiten, zwischen Entwicklungsständen zu navigieren. Über Git lassen sich ganz einfach verschiedene Artefakte gemeinsam verwalten. Dadurch ist transparent welche Dateien in welcher Version zusammengehören. Fehlersuche und Wiederherstellen von vorherigen Entwicklungsständen werden einfacher.
• Testing- und Deployment-Pipelines: Continuous Integration (CI) und Continuous Deployment (CD) ermöglichen automatisiertes Testen und Ausrollen von Artefakten, wodurch die Qualität und Geschwindigkeit der Entwicklung erhöht werden kann. Die klassische Softwareentwicklung hat an dieser Stelle schon zahlreiche Probleme gelöst - es stehen Tools und Frameworks bereit, die auch für die Low-Code-Entwicklung genutzt werden können.
• Code-Qualitäts-Tools: Tools wie SonarQube helfen, Code-Standards einzuhalten und potenzielle Probleme frühzeitig zu erkennen. Es können Regeln entworfen werden, die automatisch bei jeder Änderung geprüft werden. Das Ausbringen von Entwicklungsständen in produktive Umgebungen, die eine unzureichende Qualität aufweisen, kann ganz einfach verhindert werden.
• Impact-Analysen und Vulnerability-Checks: Tools wie Dependabot oder Snyk ermöglichen die Überwachung von Sicherheitslücken und die Durchführung von Impact-Analysen, um potenzielle Risiken zu minimieren. Paketmanager wie npm ermöglichen das versionierte Verwalten unterschiedlicher Dateien. Wiederverwendbare Integrationen oder Formulare können in einem Paket gemeinsam versioniert und anderen Projekten zur Verfügung gestellt werden. Durch die Kombination mit den zuvor genannten Tools ergeben sich weitreichende Möglichkeiten, Integrationen einfach, transparent und nachhaltig in Low-Code-Projekten zu nutzen.

Zusammenfassung

Low-Code-Prozessautomatisierung bietet viele Vorteile bei der Implementierung von Automatisierungsprojekten, bringt jedoch auch einige Herausforderungen mit sich. Anwender sollten sich daher der möglichen Schwierigkeiten bewusst sein und bestehende Entwicklungs-Technologien und Lösungsansätze nutzen, um diese zu bewältigen. Durch die Kombination von Low-Code- und Pro-Code-Ansätzen können Anwender effizientere und sicherere Automatisierungslösungen erstellen, die den Anforderungen der modernen Geschäftswelt gerecht werden.