settings
OTEX_BIGISTQB®
Süddeutsche Zeitung Institut Auszeichnung
Image
Alle Flutter Schulungen

Schulung Flutter App Engineering: Moderne Mobile Apps mit Firebase, AI und Clean Architecture

Cross-Platform-Apps für iOS, Android, Web und Desktop produktiv bauen

5 Tage / S6962
Neues Seminar
Per E-Mail senden

Schulungsformen

Inhouse-/Firmenschulung

  • 5 Tage - anpassbar
  • Termin nach Wunsch
  • In Ihrem Hause oder bei der GFU
  • Preis nach Angebot
  • Lernumgebung in der Cloud
  • Inhalte werden auf Wunsch an die Anforderungen Ihres Teams angepasst.
Präsenz Online Hybrid
Unverbindlich anfragen

Beschreibung

Flutter ist 2026 das dominante Cross-Platform-UI-Framework für Mobile, Web und Desktop - mit Reichweite über iOS, Android, Web, Windows, macOS und Linux aus einer einzigen Codebase. Im Vergleich zu React Native (JavaScript-Bridge), .NET MAUI (Microsoft-Stack), Kotlin Multiplatform (geteilte Logik, native UI) oder nativen Stacks (Swift/SwiftUI, Kotlin/Jetpack Compose) bietet Flutter den eigenen Rendering-Stack mit Skia/Impeller, eine konsistente UI über alle Plattformen und durch Dart 3 eine moderne, statisch typisierte Sprache mit Records, Patterns und Sealed Classes.
Hinter den Kulissen hat sich der Flutter-Stack 2024-2026 stark professionalisiert: Riverpod 3 und Bloc 9 als ausgereifte State-Management-Optionen, go_router als de-facto-Standard für Navigation, Firebase mit reichhaltigem Backend-Ökosystem (FlutterFire), Genkit als Agent-Framework, Gemini und Vertex AI als AI-Integrationsoptionen, Material 3 als Design-Standard, adaptives Design für Tablets und Desktop, DartPad und VS Code als Hauptarbeitsumgebungen. Gleichzeitig sind viele Flutter-Codebases noch in der Tutorial-Phase: Single-File-Widgets, vermischte Geschäftslogik in der UI, fehlende Tests, manuelle Releases. Dieses Fünf-Tage-Seminar gibt einen praxisorientierten Überblick über produktionsreifes Flutter-Engineering: Architektur, State Management, Backend-Integration, AI, Testing und CI/CD bis zum Store.

Entdecken Sie auch unsere anderen Flutter Seminare.

Schulungsziel

Jede teilnehmende Person verlässt das Seminar mit einem strukturierten Verständnis von Modern Flutter und Dart 3 (Sprachfeatures, Patterns, Sealed Classes, Material 3, adaptives Design), der Beherrschung von State Management mit Riverpod und Bloc inklusive Auswahlkriterien, der Routine in Navigation und Networking (go_router, dio, freezed, lokales Caching), dem Werkzeugkasten für Firebase als Backend (Auth, Firestore, Storage, Cloud Functions, Remote Config, Crashlytics, App Check), der Praxis in AI-Integration (Gemini, Vertex AI, Genkit, Streaming, sichere Backend-Vermittlung), dem Verständnis von Clean Architecture (Schichtentrennung, Repository-Pattern, Dependency Injection mit get_it/Riverpod), der vollständigen Test-Disziplin (Unit, Widget, Golden, Integration mit Patrol), den Performance-Strategien (DevTools-Profiler, const-Optimierung, Memory-Leaks, App-Size), der CI/CD-Routine (Multi-Plattform-Builds, Code Signing, Store-Release), dem verantwortungsvollen Umgang mit AI-Coding-Tools und einer konkreten Roadmap für die eigene Organisation - produktiv einsetzbar in modernen Flutter-Projekten von der ersten Architektur-Skizze bis zum Store-Release.

Details

Inhalt

Tag 1: Dart 3, Flutter 3.x und UI-Architektur
1. Dart 3: Sprachfeatures und Patterns
  • Ziele und Erwartungen der Teilnehmenden
    • Klärung individueller Lernziele und Erwartungen für ein praxisnahes und relevantes Seminar
  • Dart-3-Sprachfeatures: Sound Null Safety, Records, Patterns, Sealed Classes, Switch Expressions, Pattern Matching, Class Modifiers (final, base, sealed, interface, mixin).
  • Asynchronität: Future, Stream, async/await, FutureBuilder vs. StreamBuilder, Isolates für CPU-intensive Aufgaben.
  • Generics, Extension Methods, Mixins als Dart-spezifische Features.
  • Funktionsorientierte Patterns mit Records und destructuring; Algebraic Data Types via Sealed Classes.
  • DartPad und das Dart-CLI: Tooling, Linter (very_good_analysis, lint), pub.dev-Pakete.
  • Praxis-Übung: Eine Dart-Konsolen-Anwendung mit Records, Sealed Classes und Pattern Matching schreiben, die typische Domain-Modelle (Order mit Pending/Approved/Rejected) abbildet.
2. Flutter 3.x: Widgets, Layouts und Material 3
  • Flutter-Architektur: Widget-Tree, Element-Tree, RenderObject-Tree; StatelessWidget vs. StatefulWidget; Build-Lifecycle.
  • Layout-System: Box-Constraints, Flex, Stack, Slivers, CustomScrollView, GridView.
  • Material 3 und Adaptive Design: ColorScheme.fromSeed, dynamic color, large screen breakpoints, platform-adaptive Widgets, NavigationRail vs. BottomNavigationBar.
  • Theming und Typography: ThemeData, ThemeExtensions, ColorScheme, TextTheme, Material 3 vs. Cupertino.
  • Internationalisierung mit intl und ARB-Files, Gen-l10n-Workflow.
  • Animations: implicit (AnimatedContainer, AnimatedSwitcher), explicit (AnimationController, Tween), Hero-Animations.
  • DevTools: Widget Inspector, Performance Profiler, Memory Snapshot, Network Inspector.
  • Praxis-Übung: Eine Material-3-App mit dynamischem Color-Schema, dunklem und hellem Theme, adaptivem Layout (BottomBar auf Mobile, Rail auf Tablet, Drawer auf Desktop) und einer Hero-Animation zwischen Listen- und Detail-Screen bauen.
Tag 2: State Management, Navigation und Networking
3. State Management mit Riverpod und Bloc
  • Überblick: setState, Provider, Riverpod, Bloc, Cubit, GetX, MobX, Signals - Tradeoffs und 2026-Empfehlungen.
  • Riverpod 3 vertieft: Providers (StateProvider, FutureProvider, StreamProvider, NotifierProvider, AsyncNotifierProvider), Code-Generation mit riverpod_generator, ProviderScope, ref.watch vs. ref.read.
  • Riverpod-Patterns: Family-Provider für parametrisierte State, AutoDispose für Lifecycle, ConsumerWidget vs. ConsumerStatefulWidget, Dependencies zwischen Providern.
  • Bloc 9 vertieft: BlocProvider, BlocBuilder, BlocListener, BlocSelector, Hydrated Bloc für Persistierung, Replay Bloc.
  • Vergleich Riverpod vs. Bloc: wann welcher Stack, Migration zwischen den Welten, Hybrid-Ansatz.
  • Anti-Patterns: zu grosser globaler State, Singletons, Tight Coupling von UI und Business Logic, Setting State von Build-Methode aus.
  • Praxis-Übung: Eine kleine App (To-Do-Liste oder Notizen) zweimal implementieren - einmal mit Riverpod, einmal mit Bloc - und Feature-Parität prüfen; Vor- und Nachteile dokumentieren.
4. Navigation mit go_router und Networking mit dio/http
  • go_router 14+: deklarative Navigation, ShellRoute für TabBar/BottomBar, StatefulShellRoute für isolierte Tab-State, Redirects für Authentifizierung, Deep Links und URL-Strategie für Web.
  • Navigator-2.0-Konzepte: RouterDelegate, RouteInformationParser, BackButtonDispatcher.
  • Type-safe Routing mit go_router_builder: Code-Generation für sichere Route-Parameter.
  • Networking: dio mit Interceptors, http-Package als Alternative, REST-Best-Practices, GraphQL mit graphql_flutter.
  • Serialisierung: json_serializable, freezed für Data Classes mit copyWith und equality, dart_mappable als Alternative.
  • Error Handling: Result-Pattern mit Sealed Classes, retry-Strategien mit Exponential Backoff, Offline-Detection.
  • Caching und Persistence: shared_preferences, hive, drift (Moor-Nachfolger) als lokale SQLite-DB, Isar als alternative Embedded-DB.
  • Praxis-Übung: Eine kleine App mit drei Tabs aufbauen, go_router_builder für type-safe Navigation, Login-Redirect mit Auth-Guard; ein REST-API-Aufruf mit dio, freezed-Modelle, Result-Pattern für Error Handling, lokales Caching mit drift.
Tag 3: Firebase, Backend-Integration und AI
5. Firebase als Backend für Flutter-Apps
  • Firebase-Plattform: Authentication, Firestore, Realtime Database, Cloud Storage, Cloud Functions, Remote Config, Cloud Messaging, App Check, Crashlytics, Analytics, Performance Monitoring, A/B Testing.
  • FlutterFire-Setup: flutterfire CLI, Multi-Plattform-Konfiguration, Plattform-spezifische Konfigurations-Dateien.
  • Authentication: Email/Password, Anonymous, Sign in with Apple, Google Sign-in, Phone Auth, Multi-Factor Auth, Custom Auth.
  • Firestore: Datenmodellierung für NoSQL, Subcollections vs. Top-Level-Collections, Indexes, Security Rules, Compound Queries.
  • Cloud Storage: Upload mit Progress, sichere Download-URLs, Security Rules.
  • Cloud Functions für Backend-Logik: 2nd-Generation-Functions, Firestore-Triggers, Pub/Sub, HTTP-Functions, Scheduled Functions.
  • Remote Config: Feature Flags, A/B Testing, Roll-out-Strategien.
  • Crashlytics, Analytics, Performance Monitoring: Setup, Custom Events, Symbolisierung, DSGVO-konforme Konfiguration.
  • App Check: Schutz vor Missbrauch der Backend-Endpoints, integration mit DeviceCheck und Play Integrity.
  • Praxis-Übung: Eine Flutter-App mit Firebase Auth (Email + Google), Firestore-CRUD für User-Daten, Storage-Upload für Profilbilder und Crashlytics aufsetzen; Security Rules schreiben und testen.
6. AI-Integration: Gemini, Vertex AI und Genkit
  • AI-Optionen für Flutter-Apps 2026: Gemini-API direkt (firebase_ai), Vertex AI (über Cloud Functions), OpenAI-API, Anthropic-API, Azure OpenAI, lokale Modelle (TFLite, MediaPipe, Gemma on-device).
  • Firebase AI für Flutter: integrierter Zugriff auf Gemini-Modelle, multi-modal (Text, Bild, Audio), Streaming-Antworten.
  • Use Cases in Mobile-Apps: Chatbots, Bildanalyse, Voice-to-Text und Text-to-Voice, intelligente Empfehlungen, Content-Moderation, OCR, Document Understanding.
  • Vertex AI für komplexere Szenarien: Custom-Modelle, RAG-Pipelines, Agent-Workflows, Vector Search.
  • Genkit als Agent-Framework: Tools, Flows, Trace-Integration, Deployment auf Cloud Functions.
  • AI-spezifische Mobile-Themen: Latenz und Streaming, Offline-Fallback mit lokalen Modellen, Datenschutz (PII in Prompts), Cost-Tracking pro User, Rate Limiting.
  • Sicherheit: API-Keys niemals in Client-Code, Backend als Vermittler, App Check als Endpoint-Schutz.
  • AI-Coding für Flutter-Entwicklerinnen und -Entwickler: GitHub Copilot, Cursor, Claude Code, Gemini in Android Studio - Use Cases, Risiken (halluzinierte Pakete, falsche Pfade), Coding-Policy.
  • Praxis-Übung: Eine Chat-Funktion mit Streaming-Antworten via Gemini in eine Flutter-App integrieren: Backend-Vermittlung über Cloud Functions, App Check, Cost-Tracking pro User; Bildanalyse-Feature mit multi-modalem Prompt.
Tag 4: Clean Architecture, Testing und Performance
7. Clean Architecture für Flutter und Dependency Injection
  • Clean-Architecture-Schichten: Presentation (Widgets, ViewModels), Application (UseCases), Domain (Entities, Repositories als Interfaces), Data (Repository-Implementierungen, Data Sources).
  • Feature-First vs. Layer-First Folder-Struktur: Tradeoffs in grossen Codebases.
  • Repository-Pattern mit Interfaces in Domain und Implementierungen in Data; Mock-Repositories für Tests.
  • Dependency Injection: get_it, Riverpod als DI, injectable für Code-Generation.
  • Sealed Classes für Result-Types und Domain Errors, Either-Pattern mit fpdart für funktionale Fehler-Behandlung.
  • Unidirectional Data Flow: Events -> State -> UI; Vergleich mit Redux-/MVI-Patterns.
  • Modularisierung: Multi-Package-Workspaces mit melos, federated Plugins, getrennte Pakete für Domain/Data/Presentation in grossen Apps.
  • Anti-Patterns: God-Widgets, BuildContext-Leakage, hardcoded Dependencies, Singleton-Misuse.
  • Praxis-Übung: Eine Flutter-Feature (z. B. Notizen-Synchronisation) mit Clean Architecture umsetzen: Domain-Layer mit Repositories als Interfaces, Use Cases, Data-Layer mit Firestore-Implementierung, Presentation mit Riverpod; alle Dependencies via DI.
8. Testing und Performance
  • Test-Pyramide für Flutter: Unit Tests (Domain, UseCases), Widget Tests (Presentation), Integration Tests (End-to-End-Flows), Golden Tests für UI-Regression.
  • flutter_test als Standard-Framework, mocktail oder mockito für Mocking, fake_async für deterministische Tests, freezed für Test-Fixtures.
  • Integration Testing mit integration_test-Package, Patrol als modernes Framework für komplexe E2E-Szenarien.
  • Test-Coverage-Tracking, CI-Integration, Test-Performance-Optimierung.
  • Test-Driven Development für Flutter: typische Workflows, Pattern für TDD in UI-Komponenten.
  • Performance-Optimierung: const constructors, const widgets, RepaintBoundary, DevTools-Profiler, Frame-Time-Analyse.
  • Memory-Leaks erkennen: Memory-Snapshot-Workflow in DevTools, häufige Leak-Quellen (Streams, Listeners, Timers, Animation-Controllers).
  • Build-Optimierung: Tree-Shaking, deferred Components für Android, App-Size-Analyse mit flutter build --analyze-size.
  • Web- und Desktop-spezifische Performance-Themen: Render-Backend (CanvasKit vs. HTML), Skwasm, WASM-GC.
  • Praxis-Übung: Vollständige Test-Suite für eine Feature-Schicht schreiben: Unit Tests für Domain und UseCases, Widget Tests für UI-Komponenten, Golden Test für ein Design-System-Widget, Integration Test für einen End-to-End-Login-Flow.
Tag 5: CI/CD, Store-Release und Roadmap
9. CI/CD und Store-Release
  • CI/CD-Plattformen für Flutter: GitHub Actions, GitLab CI, Azure DevOps, Codemagic, Bitrise - Auswahlkriterien.
  • Build-Pipeline: Lint, Test, Build, Sign, Distribute; getrennte Pipelines für iOS, Android, Web, Desktop.
  • Code Signing: iOS Provisioning Profiles und Distribution Certificates, Android-Keystores, fastlane für Automation.
  • Release-Strategien: Beta-Distribution mit Firebase App Distribution, TestFlight, Google Play Internal/Closed/Open Testing, gestaffelter Rollout.
  • App Store und Google Play Konsole: Store-Listing, Screenshots, App-Bundle vs. APK, Vetting-Prozess, Privacy-Manifests, App Store Privacy Labels und Google Play Data Safety.
  • Versionierung und Release-Notes: Semantic Versioning, Build-Numbern, Changelog-Generierung.
  • Web- und Desktop-Distribution: Hosting auf Firebase Hosting, Vercel, Cloudflare Pages; Microsoft Store, Mac App Store, Linux-Distribution mit snap/flatpak/AppImage.
  • Monitoring nach Release: Crashlytics, Performance Monitoring, A/B Testing mit Remote Config, User Feedback mit In-App-Surveys.
  • Praxis-Übung: GitHub-Actions-Pipeline für eine Flutter-App definieren: Multi-Plattform-Build (iOS, Android, Web), Tests, Code Signing mit fastlane match, Distribution an Firebase App Distribution für Beta, Store-Submission als manuelle Stage.
10. AI-Assisted Flutter Development und Roadmap
  • AI-Coding für Flutter-Entwicklerinnen und -Entwickler: GitHub Copilot, Cursor, Claude Code, Gemini in Android Studio, IntelliJ AI Assistant - Use Cases (Widget-Generierung, State-Management-Refactoring, Test-Generierung, Bug-Hunting).
  • AI-spezifische Risiken in Flutter: halluzinierte Pakete oder Cmdline-Parameter, übersehene Null-Safety-Implikationen, falsche Async-Patterns, Slopsquatting bei pub.dev-Empfehlungen.
  • Sichere AI-Integration: Tool-Auswahl, Code-Review-Pflicht für kritische Flows, AI-Coding-Policy für Mobile-Teams.
  • Plattform-übergreifende Entwicklung: Flutter for Web Production-Tipps, Flutter Desktop (Windows, macOS, Linux), Flutter on Embedded (Toyota, Sony, Linux IoT).
  • Migration und Modernisierung bestehender Codebases: von setState zu Riverpod, von provider zu Riverpod, von Navigator 1.0 zu go_router, von Material 2 zu Material 3.
  • Reife-Modell für Flutter-Teams: Tutorial-Codebase -> strukturierte App -> Clean Architecture -> Multi-Package-Plattform.
  • KPIs für Flutter-Projekte: Build-Time, Test-Coverage, Crash-Free-Rate, ANR-Rate, Adoption-Rate, App-Size, Cold-Start-Zeit.
  • Praxis-Übung: Konkreten Drei-Phasen-Plan für ein Flutter-Projekt der eigenen Organisation skizzieren: Quick Wins (Material 3, go_router), Foundation (Clean Architecture, Tests, CI/CD), Maturity (Multi-Package, AI-Features). Drei Antipatterns benennen, die im eigenen Projekt drohen, mit Gegenmassnahmen.

  • Mobile-Entwicklerinnen und -Entwickler: Die von nativem iOS/Android oder React Native auf Flutter wechseln oder Flutter strukturiert vertiefen wollen.
  • Full-Stack-Entwicklerinnen und -Entwickler: Die ihre Cross-Platform-Reichweite um Flutter und Dart 3 erweitern wollen, mit produktivem Backend (Firebase, eigene REST/GraphQL).
  • Tech Leads und Software-Architekten: Die Flutter als strategische Cross-Platform-Wahl evaluieren und Clean-Architecture-Patterns für Mobile-Teams etablieren.
  • Junior-Entwicklerinnen und -Entwickler mit Flutter-Grundlagen: Die nach ersten Tutorials den Sprung zu produktionsreifen Apps mit AI, Backend, Tests und Store-Release machen wollen.
Voraussetzungen: Solide Programmiererfahrung in einer objektorientierten Sprache (Java, Kotlin, Swift, C#, TypeScript). Erste Berührung mit Flutter und Dart oder mit einem anderen Mobile-Framework ist hilfreich. Vertrautheit mit Git, REST-APIs und JSON. Eigenes MacBook oder ein vergleichbarer Mac-Zugang ist für iOS-Builds nötig (iOS-Builds sind anders nicht möglich); Android- und Web-Builds funktionieren auf jedem OS.
Abgrenzung: Behandelt produktive Flutter-Praxis mit Firebase, AI und Clean Architecture - nicht reine Dart-Programmiergrundlagen ohne Mobile-Kontext, nicht native iOS- oder Android-Entwicklung in Tiefe (Swift/SwiftUI, Kotlin/Jetpack Compose), nicht React Native oder andere Cross-Platform-Frameworks (Capacitor, .NET MAUI, Kotlin Multiplatform), nicht reine Backend-Entwicklung ohne Mobile-Bezug. Fokussiert auf produktionsreife Mobile- und Multi-Platform-Apps von der Architektur bis zum Store-Release.


In Präsenz
Online
Lernmethode

Ausgewogene Mischung aus Theorie und praktischen Übungen auf persönlichem Schulungs-PC.

Wie auch bei unseren Präsenz-Seminaren: Ausgewogene Mischung aus Theorie und praktischen Übungen. Trainer durchgehend präsent.

Unterlagen

Seminarunterlagen oder Fachbuch inklusive. Das Fachbuch wählt der Trainer passend zum Seminar aus - Ihren individuellen Buch-Wunsch berücksichtigen wir auf Nachfrage gerne.

Seminarunterlagen oder Fachbuch inklusive (via DHL). Das Fachbuch wählt der Trainer passend zum Seminar aus - Ihren individuellen Buch-Wunsch berücksichtigen wir auf Nachfrage gerne.

Arbeitsmaterialien

Din A4 Block, Notizblock, Kugelschreiber, USB-Stick, Textmarker, Post-its

Teilnahmezertifikat

Nach Abschluss des Seminars erhalten Sie das Teilnahmezertifikat inkl. Inhaltsverzeichnis per E-Mail als PDF.


In Präsenz
Online
Teilnehmendenzahl

min. 1, max. 8 Personen

Garantierte Durchführung *

Ab 1 Teilnehmenden

Schulungszeiten
5 Tage, 09:00 - 16:00 Uhr
Ort der Schulung
GFU Schulungszentrum oder Virtual Classroom
GFU Schulungszentrum
Am Grauen Stein 27
51105 Köln-Deutz

oder online im Virtual Classroom oder europaweit bei Ihnen als Inhouse-Schulung

Um ein optimales Raumklima zu gewährleisten, haben wir das Schulungszentrum mit 17 hochmodernen Trotec TAC V+ Luftreinigern ausgestattet. Diese innovative Filtertechnologie (H14 zertifiziert nach DIN EN1822) sorgt dafür, dass die Raumluft mehrfach pro Stunde umgewälzt wird und Schadstoffe zu 99.995% im HEPA-Filter abgeschieden und infektiöse Aerosole abgetötet werden.

Zusätzlich sind alle Räume mit CO2-Ampeln ausgestattet, um jederzeit eine hervorragende Luftqualität sicherzustellen.

Räumlichkeiten

Helle und modern ausgestattete Räume mit perfekter Infrastruktur

Bequem aus dem Homeoffice von überall

All-Inclusive

Frühstück, Snacks und Getränke ganztägig, Mittagessen im eigenen Restaurant, täglich 6 Menüs, auch vegetarisch

Eine Auswahl unserer Frühstücks-Snacks und Nervennahrungs-Highlights senden wir Ihnen mit den Seminarunterlagen via DHL zu.
Barrierefreiheit

Das GFU-Schulungszentrum (Am Grauen Stein 27) ist barrierefrei

-

In Präsenz
Online
  • Eigener Shuttle-Service
  • Reservierte Parkplätze
  • Hotelreservierung
  • Technik-Sofort-Support

Buchungsmöglichkeiten

Online oder in Präsenz teilnehmen

Sie können sowohl Online als auch in Präsenz am Seminar teilnehmen. Klicken Sie bei Ihrer Buchung oder Anfrage einfach die entsprechende Option an.

Mehr Infos
Inhouse-/Firmenschulung
  • Lernumgebung in der Cloud
  • Inhalte werden auf Wunsch an die Anforderungen Ihres Teams angepasst.
Präsenz Online Hybrid
Unverbindlich anfragen

So haben GFU-Kunden gestimmt

Zu diesem Seminar wurden noch keine Bewertungen abgegeben.

FAQ für Inhouse Schulungen

Bei einer offenen Schulung stehen Ort und Termin vorab fest. Jeder Interessent kann eine offene Schulung buchen, daher treffen Teilnehmer aus verschiedenen Unternehmen aufeinander.

Inhouse Schulungen können auf Ihren individuellen Schulungsbedarf zugeschnitten werden. Sie bestimmen den Teilnehmerkreis, Termin und Schulungsort.

Bei einer Inhouse Schulung gehen wir auf die individuellen Bedürfnisse Ihres Unternehmens ein und decken den Schulungsbedarf direkt bei Ihnen im Unternehmen ab.

Das spart Zeit und Geld und sorgt für einen schnellen Wissenstransfer Ihrer Mitarbeiter.

Eine komplette Lernumgebung in der Cloud mit Remote Zugriff ist für uns selbstverständlich. Sie müssen sich um nichts kümmern. Lediglich ein funktionierender PC oder Notebook mit Internetanschluss sollte für jeden Teilnehmer am Schulungstag bereit stehen.

  • Kompetente Seminarberatung
  • Dozenten aus der Praxis
  • Auf Ihre Bedürfnisse zugeschnittener individueller Lernstoff
  • Sie können den Termin flexibel gestalten, so wie es für Sie am besten passt
  • Unsere Inhouse Schulungen können Europaweit durchgeführt werden
  • Der Fokus liegt auf Ihrem Schulungsbedarf, somit schonen Sie Ihr Budget
  • Wissenslücken Ihrer Mitarbeitet werden schnell geschlossen

Verwandte Seminare

aegallianzaxaElement 1deutsche-bankdeutsche-postlufthansamercedessonyzdf
160.215
Teilnehmende
4.750
Seminarthemen
39.088
Durchgeführte Seminare