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

Schulung Symfony Framework Komplett

Modernes PHP-Framework in der aktuellen Version

4 Tage / S6994
Neues Seminar
Per E-Mail senden

Schulungsformen

Inhouse-/Firmenschulung

  • 4 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

Individualschulung

  • 4 Tage - anpassbar
  • Termin nach Wunsch
  • In Ihrem Hause oder bei der GFU
  • Preis nach Angebot
  • Lernumgebung in der Cloud
  • 1 Teilnehmender = Fokus aufs Fachliche und maximaler Raum für individuelle Fragen.
Präsenz Online Hybrid
Unverbindlich anfragen

Beschreibung

Symfony ist 2026 das führende Enterprise-PHP-Framework in DACH und Europa. Mit der aktuellen Version baut Symfony konsequent auf PHP 8.4 als Sprach-Basis und bringt eine Reihe substantieller Verbesserungen: Doctrine ORM 3 mit Attributes statt Annotations und nativen Lazy Objects, Twig 4 mit moderner PHP-8-Optimierung, API Platform 4 als integrierte Lösung für REST- und GraphQL-APIs, ObjectMapper als neue Komponente für saubere DTO-zu-Entity-Mappings (vergleichbar mit .NET AutoMapper) und JSON-basierte Konfiguration als moderne Alternative zur traditionellen XML- und YAML-Welt.
PHP 8.4 selbst bringt mit Property Hooks , Asymmetric Visibility und erweiterten Array-Funktionen Features, die Symfony-Entwickler-Code substantiell schlanker machen. Die Kombination aus moderner Sprach-Basis und Framework-Reife macht Symfony 2026 zur natürlichen Wahl für Enterprise-PHP-Projekte - von Mittelstands-Webshops über Behörden-Portale bis zu mikroservice-basierten Konzern-Architekturen.
Dieses Vier-Tage-Seminar vermittelt Symfony systematisch und mit klarem Fokus auf produktive Einsatzfähigkeit. Tag 1 legt die Architektur-Grundlagen, Tag 2 vertieft Doctrine und Datenbank-Zugriff, Tag 3 behandelt Forms, Security und APIs, Tag 4 deckt moderne Komponenten wie ObjectMapper und Messenger sowie Testing und Deployment ab.

Finden Sie den richtigen Symfony Kurs aus unserem Portfolio.

Schulungsziel

Jede teilnehmende Person verlässt das Seminar mit einem strukturierten Verständnis von Symfony als Komplett-Framework in der aktuellen Version, der Beherrschung der PHP-8.4-Features im Symfony-Kontext (Property Hooks, Asymmetric Visibility, Native Lazy Objects), der Routine in HTTP-Foundation, Routing und Controller-Patterns, der Praxis in Doctrine 3 mit Attributes und nativen Lazy Objects, dem Werkzeug für Twig-4-Templates mit AssetMapper und Asset-Management, der Beherrschung von Forms und Validator mit DTO-Schicht-Disziplin, der Praxis in Security mit JWT, OAuth2 und SSO-Integration, dem Werkzeug API Platform 4 für REST- und GraphQL-APIs, der Routine in JSON-basierter Konfiguration als Alternative zu YAML und XML, der Beherrschung des neuen ObjectMapper für saubere DTO- und Entity-Mappings, der Praxis in Messenger für asynchrone Verarbeitung und einer Test- und Deployment-Disziplin mit PHPUnit, Symfony Panther und CI/CD-Pipelines - produktiv einsetzbar in DACH-Web-Projekten ab dem ersten Arbeitstag nach dem Seminar.

Details

Inhalt

Tag 1: Architektur, Grundlagen und PHP 8.4 als Plattform
1. Symfony-Architektur und Setup
  • Ziele und Erwartungen der Teilnehmenden
    • Klärung individueller Lernziele und Erwartungen für ein praxisnahes und relevantes Seminar
  • Symfony-Architektur 2026: Bundles, Services, Dependency Injection Container, Event Dispatcher.
  • Projekt-Struktur: src/, config/, templates/, public/, var/ - Disziplin und Konventionen.
  • Composer und Symfony Flex: Recipes, Aliases, Setup-Automatisierung.
  • Symfony CLI: Server starten, Cache leeren, Maker Bundle für Code-Generation.
  • Konfigurations-Welten 2026: YAML als Standard, JSON als moderne Alternative , PHP für komplexe Setups, XML als Legacy.
  • Environment-Konfiguration: dev, test, prod; .env-Datei-Disziplin, Secrets-Management.
  • Symfony-Versionierung: LTS-Strategie, Major-Versionen, Migrations-Pfade.
  • Anti-Patterns: zu viele Bundles, fehlende DI-Disziplin, Konfiguration im Code statt in Konfigurations-Dateien.
  • Praxis-Übung: Symfony-Projekt mit Symfony CLI aufsetzen, Standard-Verzeichnisstruktur erkunden, eine einfache Konfiguration in YAML, JSON und PHP parallel schreiben und Unterschiede dokumentieren.
2. PHP 8.4 als Plattform-Basis im Symfony-Kontext
  • PHP-8.4-Features im Überblick: Property Hooks (get/set ohne Boilerplate), Asymmetric Visibility (public read, private write), neue Array-Funktionen (array_find, array_find_key), Lazy Objects nativ.
  • Property Hooks in Symfony-Entities und DTOs: weniger Boilerplate-Getter/Setter, sauberere Validierungs-Logik.
  • Asymmetric Visibility für Value Objects: unveränderbare Felder ohne klassische Immutability-Patterns.
  • Native Lazy Objects: Performance-Vorteile in Doctrine, Symfony und Custom-Code.
  • Type System Updates: erweiterte Generics-Annotation-Unterstützung über PHPStan und Psalm.
  • Match-Expression-Patterns für Symfony-Routing und Service-Logik.
  • Readonly Classes und Constructor Property Promotion in Symfony-Services.
  • Anti-Patterns: alte Boilerplate-Patterns weiternutzen statt PHP 8.4-Features anzunehmen.
  • Praxis-Übung: Eine bestehende PHP-7-Klasse zu PHP 8.4 modernisieren - Property Hooks statt Getter/Setter, Asymmetric Visibility für Read-only-Felder, Constructor Property Promotion; Lesbarkeits- und Code-Reduktions-Vergleich dokumentieren.
3. HTTP-Foundation, Routing und Controller
  • HTTP-Foundation: Request- und Response-Objekte als objektorientierte HTTP-Abstraktion.
  • Routing-Disziplin: Route Attributes (#[Route]), Route-Konfiguration in YAML/JSON, Route Parameters, Requirements, Defaults.
  • Controller-Patterns: einzelne Controller-Methoden, Action-Klassen, Single-Action-Controllers für API-Endpunkte.
  • Response-Typen: HtmlResponse, JsonResponse, RedirectResponse, StreamedResponse, BinaryFileResponse.
  • Argument Resolvers: automatische Injection von Request-Daten, Route-Parametern, Services, Entities.
  • Middleware-ähnliche Patterns mit Event Listeners und Subscribers.
  • Anti-Patterns: zu fette Controller, fehlende Trennung von Controller und Service-Logik.
  • Praxis-Übung: Einfache Web-Anwendung mit drei Routen aufbauen - Listen-View, Detail-View, JSON-API-Endpunkt; Argument Resolver für automatisches Entity-Loading nutzen.
Tag 2: Doctrine 3, Datenbank-Zugriff und Twig 4
4. Doctrine ORM 3 mit Attributes und nativen Lazy Objects
  • Doctrine 3-Architektur: ORM, DBAL, Migrations als drei separate Komponenten.
  • Wechsel von Annotations zu Attributes: #[Entity], #[Column], #[ManyToOne] - moderne PHP-8-Syntax.
  • Native Lazy Objects (PHP 8.4): Performance-Verbesserungen gegenüber klassischem Proxy-Pattern.
  • Type Safety: native Typed Properties in Entities, strikt-typisierte Repository-Methoden.
  • Beziehungen modellieren: OneToOne, OneToMany, ManyToMany; Cascade-Operationen, Orphan Removal.
  • Repository-Disziplin: dedizierte Repository-Klassen, Query Builder, DQL, native SQL.
  • Doctrine Migrations: Schema-Versionierung, Diff-Generierung, Rollback-Strategien.
  • Performance-Optimierung: N+1-Probleme erkennen, Eager Loading mit JOIN, Query Cache.
  • Doctrine Extensions: Timestampable, Sluggable, Translatable als populäre Erweiterungen.
  • Anti-Patterns: Repository-Logik in Controllern, fehlende Lazy-Loading-Disziplin, ungeprüfte N+1-Probleme.
  • Praxis-Übung: Datenmodell für einen Web-Shop mit fünf Entities aufbauen (User, Product, Category, Order, OrderItem) - Beziehungen mit Attributes definieren, Repository-Methoden mit Query Builder schreiben, Migrations generieren und ausführen.
5. Twig 4 als Template-Engine
  • Twig-4-Architektur: erweiterte PHP-8-Optimierung, verbesserte Performance, neue Tag-Syntax-Optionen.
  • Template-Vererbung: Layout-Templates, Blocks, Includes, Embeds.
  • Filter und Functions: integrierte Filter, Custom Filters via Extensions, Twig Functions für komplexe Logik.
  • Form-Rendering mit Twig: form_start, form_widget, form_label, Custom-Form-Themes.
  • Asset-Management: AssetMapper als moderne Alternative zu Webpack Encore, importmaps, native ESM-Unterstützung.
  • I18n und Übersetzungen: trans-Filter, ICU-Format, Pluralisierung, Translation-Keys-Disziplin.
  • Performance: Template-Caching, OpCache, Partial-Rendering.
  • Sicherheit: automatisches HTML-Escaping, raw-Filter mit Vorsicht, XSS-Vermeidung.
  • Anti-Patterns: Logik in Templates statt in Controllern oder Services, fehlende Layout-Disziplin, manuelle Kontatenations-Strings.
  • Praxis-Übung: Web-Shop-Frontend mit Twig 4 aufbauen - Layout-Template mit drei Blocks, Listen-Template mit Twig-Filtern, Detail-Template mit eingebetteten Komponenten, Custom-Form-Theme für Markenkonsistenz.
6. Forms und Validator
  • Forms-Komponente: Form-Type-Klassen, FormBuilder, Form-Rendering.
  • Field-Types: TextType, ChoiceType, DateType, FileType, CollectionType, EntityType.
  • Daten-Mapping: Forms zu Entities, Forms zu DTOs, Forms zu Plain-Arrays.
  • Validator-Komponente: Constraints (NotBlank, Email, Length, Regex, Choice, Callback, Custom).
  • Validator und Forms-Integration: Constraint Definition mit Attributes auf Entities/DTOs.
  • Form-Events: PRE_SET_DATA, POST_SET_DATA, PRE_SUBMIT, SUBMIT, POST_SUBMIT.
  • CSRF-Schutz: automatisch in Forms, manuelle Disziplin in API-Endpunkten.
  • File Uploads: VichUploaderBundle, native FileType, Symfony Filesystem.
  • Anti-Patterns: Forms direkt auf Entities ohne DTO-Schicht, fehlende Validator-Disziplin, manuelle CSRF-Implementierung.
  • Praxis-Übung: Bestell-Formular für den Web-Shop bauen - mit drei Field-Types, Validator-Constraints, Daten-Mapping zu DTO, Custom-Validator-Constraint für Geschäfts-Logik.
Tag 3: Security, APIs und JSON-Konfiguration
7. Security: Authentifizierung und Autorisierung
  • Security-Komponente: Authenticators, User Providers, Firewalls, Access Control.
  • Authenticators 2026: AbstractAuthenticator-Pattern, JWT-basierte Authentication, OAuth2-Integration.
  • User Providers: EntityUserProvider, ChainUserProvider, Custom Providers für externe Auth-Systeme.
  • Password Hashing: Argon2id als Standard, Hashing-Konfiguration, Migration alter Passwörter.
  • Authorization: Voters, Access Control Rules, Roles und Hierarchies.
  • Security Events: AuthenticationSuccess, AuthenticationFailure, LogoutEvent.
  • API-Authentication-Patterns: API Tokens, JWT mit LexikJWTAuthenticationBundle, OAuth2.
  • SSO-Integration: SAML, OIDC mit Microsoft Entra ID, Google Workspace, Keycloak.
  • Anti-Patterns: Custom-Hashing-Algorithmen, fehlende CSRF-Disziplin in Forms, Authentifizierung im Controller statt im Authenticator.
  • Praxis-Übung: Login-System für den Web-Shop bauen - Form-basierte Authentication für Customer, JWT-basierte API-Authentication für Mobile-Client, Voter für Bestell-Berechtigung, OIDC-Integration mit Keycloak.
8. API Platform 4 für REST und GraphQL
  • API Platform 4-Architektur: ApiResource-Attribute, automatische CRUD-Endpunkte, OpenAPI-Dokumentation.
  • Resource-Definition: ApiResource-Attribute auf Entities oder dedizierte DTOs als API-Resources.
  • HTTP-Methoden und Operations: GetCollection, Get, Post, Put, Patch, Delete; Custom Operations.
  • Filtern, Sortieren, Pagination: SearchFilter, OrderFilter, Pagination-Standards (Cursor- vs. Offset-basiert).
  • State Providers und Processors: Datenquelle und Daten-Verarbeitung als getrennte Verantwortlichkeiten.
  • GraphQL-Endpunkt automatisch aus ApiResource-Konfiguration.
  • Validator-Integration: API-Validation mit den gleichen Constraints wie Forms.
  • Security-Integration: ApiResource-Security-Attribute, Voters, JWT-Authentication.
  • OpenAPI-Dokumentation und Swagger-UI integriert.
  • Anti-Patterns: Resources direkt auf Entities ohne DTO-Schicht, fehlende Versionierungs-Disziplin, fehlendes Rate-Limiting.
  • Praxis-Übung: REST-API für den Web-Shop mit API Platform aufbauen - Product- und Order-Resources mit DTO-Schicht, Filter und Pagination, Security mit JWT, OpenAPI-Dokumentation prüfen, GraphQL-Endpunkt testen.
9. JSON-basierte Konfiguration als moderne Alternative
  • Konfigurations-Welten in Symfony: YAML, XML, PHP, JSON .
  • Wann JSON sinnvoll ist: API-getriebene Konfigurations-Tools, Frontend-Backend-Konsistenz, AI-Tool-Integration (ChatGPT, Claude generieren JSON nativ besser als YAML).
  • JSON-Konfiguration in der Praxis: Services, Routes, Bundles, Parameters in JSON.
  • Vergleich JSON vs. YAML: Lesbarkeit, Tool-Unterstützung, Kommentare-Disziplin (JSON kennt keine Kommentare).
  • Konvertierungs-Tools: YAML-zu-JSON, XML-zu-JSON, automatisierte Migration für Legacy-Projekte.
  • Hybrid-Strategien: JSON für maschinengenerierte Konfigurationen, YAML für menschen-geschriebene.
  • Anti-Patterns: blinde Migration ohne Konsistenz-Disziplin, fehlende Kommentar-Strategie bei JSON.
  • Praxis-Übung: Bestehende YAML-Konfiguration des Web-Shop-Projekts in JSON umwandeln - Services, Routes, Parameter parallel halten, Lesbarkeits-Vergleich dokumentieren, Hybrid-Setup definieren.
Tag 4: ObjectMapper, Messenger, weitere Komponenten und Testing
10. ObjectMapper als neue Symfony-Komponente
  • ObjectMapper-Konzept: deklaratives Mapping zwischen Objekten, vergleichbar mit .NET AutoMapper.
  • Use Cases: Entity-zu-DTO, DTO-zu-Entity, API-Resource-zu-Domain-Model, Form-Daten-zu-Command-Object.
  • Mapping-Konfiguration: Attribute auf Klassen, automatisches Property-Mapping, Custom-Transformer.
  • ObjectMapper vs. manuelle Mappings: Code-Reduktion, Konsistenz, Fehler-Vermeidung.
  • ObjectMapper vs. AutoMapper-PHP-Bibliothek: Symfony-native Integration, Performance-Aspekte.
  • Praxis-Patterns: Hexagonal Architecture mit ObjectMapper an den Architektur-Grenzen, CQRS mit Command-Objects-Mapping, API-DTOs-Mapping.
  • Limitationen: komplexe Mappings mit Geschäftslogik bleiben in dedizierten Services.
  • Anti-Patterns: ObjectMapper für simple Mappings überdimensioniert nutzen, Geschäftslogik in Mapper-Klassen.
  • Praxis-Übung: Web-Shop-Projekt um ObjectMapper erweitern - Mapping zwischen Order-Entity und OrderResponseDto definieren, Mapping zwischen CreateOrderRequestDto und Order-Entity, Custom-Transformer für Geld-Beträge.
11. Messenger für asynchrone Verarbeitung
  • Messenger-Architektur: Messages, MessageHandlers, Buses, Transports.
  • Use Cases: E-Mail-Versand, Bild-Verarbeitung, lange Berechnungen, Workflow-Automation.
  • Transports 2026: Doctrine, Redis, RabbitMQ, AMQP, Amazon SQS, Beanstalkd.
  • Synchrone vs. asynchrone Buses: wann Sync sinnvoll, wann Async nötig.
  • Failure Recovery: Retry-Strategien, Failure Transports, Dead Letter Queues.
  • Worker-Disziplin: Long-Running-Worker, Memory-Management, Graceful Shutdown.
  • Scheduler-Komponente: zeitgesteuerte Messages, Cron-Replacement, periodische Aufgaben.
  • Anti-Patterns: zu viele kleine Messages, fehlende Retry-Strategien, fehlende Failure-Beobachtung.
  • Praxis-Übung: Asynchrone Bestell-Bestätigungs-Mail im Web-Shop implementieren - OrderPlaced-Message, OrderPlacedHandler, Doctrine-Transport, Failure-Recovery; Worker im Hintergrund laufen lassen und Messages-Flow beobachten.
12. Weitere Komponenten und Integration
  • HttpClient: HTTP-Requests an externe APIs, Async-Pattern mit promises, Mock-Support für Tests.
  • Mailer: E-Mail-Versand mit Twig-Templates, mehrere Transports, asynchron via Messenger.
  • Notifier: Multi-Channel-Notifications (E-Mail, SMS, Slack, Microsoft Teams).
  • Cache-Komponente: PSR-16 SimpleCache, PSR-6 Cache, Adapter (Redis, Memcached, APCu, Filesystem).
  • Lock-Komponente: Distributed Locking für asynchrone Worker.
  • Workflow-Komponente: State Machines für Bestell-Status, Genehmigungs-Workflows, Approval-Prozesse.
  • String-Komponente: ASCII-Slugger, Inflector für Singular/Plural.
  • Translation und Locale-Handling: ICU-Format, Pluralisierung, RTL-Sprachen.
  • Praxis-Übung: Web-Shop-Projekt um drei Komponenten erweitern - externe Versand-API mit HttpClient anbinden, Bestell-Workflow mit Workflow-Komponente modellieren, Multi-Channel-Notification für Bestell-Events mit Notifier.
13. Testing, Deployment und Best Practices
  • Test-Pyramiden-Disziplin: Unit-Tests mit PHPUnit, Integration-Tests mit Symfony WebTestCase, End-to-End mit Symfony Panther.
  • Unit-Tests: Service-Tests mit Mocks, Repository-Tests mit InMemory-Implementierungen.
  • Integration-Tests: WebTestCase mit Test-Datenbank, Fixtures mit DoctrineFixturesBundle, AliceBundle für realistische Test-Daten.
  • End-to-End-Tests: Panther als browser-basiertes Test-Framework, Playwright als Alternative.
  • API-Tests mit API Platform: ApiTestCase, Schema-Validation, JSON-Path-Assertions.
  • Deployment-Patterns: Symfony auf shared Hosting (Apache, Nginx mit PHP-FPM), Docker-Container, Kubernetes mit Symfony-CLI-Helm-Charts.
  • CI/CD: GitHub Actions, GitLab CI, Symfony-spezifische Phasen (Composer Install, Cache Warmup, Migrations, Tests).
  • Performance-Optimierung in Production: OpCache, APCu, Symfony Profiler nur in Dev, lazy Loading von Bundles.
  • Monitoring: Symfony Profiler, Sentry-Integration, OpenTelemetry-Integration für distributed Tracing.
  • Best Practices und Roadmap: Symfony-Major-Versionen-Migration, Breaking Changes, LTS-Strategie.
  • Praxis-Übung: Web-Shop-Projekt mit Test-Suite ausstatten - fünf Unit-Tests, drei Integration-Tests, ein API-Test mit ApiTestCase; CI/CD-Pipeline-Skizze für GitHub Actions oder GitLab CI; Deployment-Konzept für Production skizzieren.

  • PHP-Entwicklerinnen und Entwickler: Die produktiv mit Symfony arbeiten und auf die aktuelle Version umstellen wollen.
  • Entwicklerinnen aus anderen Frameworks: Die von Laravel, CodeIgniter oder Custom-PHP zu Symfony wechseln möchten.
  • Backend-Architektinnen: Die Symfony für Web-Applikationen, APIs und Microservices in der Architektur einsetzen.
  • Tech-Leads und Senior-Developer: Die Symfony-Projekte aufsetzen, Code-Reviews durchführen und Team-Standards definieren.
Voraussetzungen: Solide PHP-Kenntnisse (Klassen, Interfaces, Namespaces, Composer). Grundlagen objektorientierter Programmierung. Verständnis von HTTP, REST und relationalen Datenbanken (MySQL, PostgreSQL). Erste Berührung mit MVC-Architekturen ist hilfreich. Kein Symfony-Vorwissen erforderlich - das Seminar startet ab den Grundlagen, geht aber zügig in die produktive Vertiefung.


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
4 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
Individualschulung
  • Lernumgebung in der Cloud
  • 1 Teilnehmender = Fokus aufs Fachliche und maximaler Raum für individuelle Fragen.
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.721
Teilnehmende
4.762
Seminarthemen
39.165
Durchgeführte Seminare