a:2:{s:14:"__file_content";s:19:"alb-saved-templates";s:18:"onepage-startseite";s:64852:"[av_fullscreen perma_caption='aviaTBperma_caption' size='extra_large' control_layout='av-control-hidden' scroll_down='aviaTBscroll_down' conditional_play='' image_attachment='' animation='fade' transition_speed='' autoplay='true' autoplay_stopper='aviaTBautoplay_stopper' interval='2' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']
[av_fullscreen_slide slide_type='image' id='578' position='center center' video='http://' mobile_image='' fallback_link='https://' title='Führen im komplexen Umfeld -<br>Werde zum Certified Agile Leader!' video_cover='' caption_pos='caption_center' custom_title_size='60' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='24' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' custom_title='#ffffff' custom_content='#ffffff' heading_tag='' heading_class='' link_apply='button button-two' link='lightbox' link_target='' button_label='Mehr erfahren' button_color='light' link1='manually,#konzept' link_target1='' button_label2='Kontakt & Buchung' button_color2='theme-color' link2='manually,#kontakt' link_target2='' overlay_enable='aviaTBaviaTBoverlay_enable' overlay_opacity='0.2' overlay_color='#000000' overlay_pattern='' overlay_custom_pattern='' av_uid='' sc_version='1.0']
Die realitätsnaheste Führungsausbildung im deutschsprachigen Raum!
[/av_fullscreen_slide]
[/av_fullscreen]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' margin='aviaTBmargin' custom_margin='0px' custom_margin_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' color='main_color' background='bg_color' custom_bg='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='ausbildung' custom_class='' template_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0']
[av_one_fifth first av_uid='']

[/av_one_fifth][av_three_fifth av_uid='']

[av_heading heading='Ausbildung Certified Agile Leadership' tag='h1' style='blockquote modern-quote modern-centered' subheading_active='' show_icon='' icon='ue800' font='entypo-fontello' size='30' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' subheading_size='15' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' icon_size='' av-medium-font-size-1='' av-small-font-size-1='' av-mini-font-size-1='' color='' custom_font='' subheading_color='' seperator_color='' icon_color='' margin='' margin_sync='true' padding='10' icon_padding='10' headline_padding='' headline_padding_sync='true' link='' link_target='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_heading]

[/av_three_fifth][av_one_fifth av_uid='']

[/av_one_fifth][av_one_third first av_uid='']

[av_image src='http://fitforleadership.ch/lead-agile-onepage-2022/wp-content/uploads/2022/02/lead-agile-certified-agile-leader-fuehrungsausbildung-4-1030x687.jpg' attachment='455' attachment_size='large' copyright='' caption='' image_size='' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='' appearance='' link='' target='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='1' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_one_third][av_one_third av_uid='']

[av_image src='http://fitforleadership.ch/lead-agile-onepage-2022/wp-content/uploads/2022/02/lead-agile-certified-agile-leader-fuehrungsausbildung-5-1030x687.jpg' attachment='456' attachment_size='large' copyright='' caption='' image_size='' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='' appearance='' link='' target='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_one_third][av_one_third av_uid='']

[av_image src='http://fitforleadership.ch/lead-agile-onepage-2022/wp-content/uploads/2022/02/lead-agile-certified-agile-leader-fuehrungsausbildung-6-1030x687.jpg' attachment='457' attachment_size='large' copyright='' caption='' image_size='' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='' appearance='' link='' target='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_one_third][av_icongrid icongrid_styling='flipbox' flipbox_force_close='' icongrid_numrow='3' icongrid_borders='none' custom_title_size='28' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_subtitle_size='' av-medium-font-size-1='' av-small-font-size-1='' av-mini-font-size-1='' custom_content_size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' custom_icon_size='' av-medium-font-size-2='' av-small-font-size-2='' av-mini-font-size-2='' icongrid_padding='0' icongrid_padding_sync='true' font_color='custom' custom_icon='#e5b433' custom_title='#e5b433' custom_subtitle='' custom_content='' bg_color='custom' custom_front_bg_type='bg_color' custom_front_bg='' custom_front_gradient_color1='' custom_front_gradient_color2='' custom_front_gradient_direction='vertical' custom_back_bg_type='bg_color' custom_back_bg='' custom_back_gradient_color1='' custom_back_gradient_color2='' custom_back_gradient_direction='vertical' border_color='' custom_grid='' custom_tooltip_border='' flip_axis='' alb_description='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']
[av_icongrid_item title='Die neuen Herausforderungen' subtitle='' icon='ue84b' font='entypo-fontello' heading_tag='' heading_class='' item_font_color='' item_custom_icon='' item_custom_title='' item_custom_subtitle='' item_custom_content='' item_bg_color='' item_custom_front_bg_type='bg_color' item_custom_front_bg='' item_custom_front_gradient_color1='' item_custom_front_gradient_color2='' item_custom_front_gradient_direction='vertical' item_custom_back_bg_type='bg_color' item_custom_back_bg='' item_custom_back_gradient_color1='' item_custom_back_gradient_color2='' item_custom_back_gradient_direction='vertical' item_border_color='' item_custom_tooltip_border='' link='' linktarget='' av_uid='' sc_version='1.0']
Unternehmen sind im Wandel. Prozesse und Strukturen ändern sich. Von dir als Führungskraft wird erwartet, dass du diese Herausforderungen bewältigst und auch in komplexen Situationen nicht nur passiv reagierst, sondern aktiv mitgestaltest und dabei eine prägende Rolle spielst.
[/av_icongrid_item]
[av_icongrid_item title='Das erlebst du in der Ausbildung zum Agile Leader/in' subtitle='' icon='ue864' font='entypo-fontello' heading_tag='' heading_class='' item_font_color='' item_custom_icon='' item_custom_title='' item_custom_subtitle='' item_custom_content='' item_bg_color='' item_custom_front_bg_type='bg_color' item_custom_front_bg='' item_custom_front_gradient_color1='' item_custom_front_gradient_color2='' item_custom_front_gradient_direction='vertical' item_custom_back_bg_type='bg_color' item_custom_back_bg='' item_custom_back_gradient_color1='' item_custom_back_gradient_color2='' item_custom_back_gradient_direction='vertical' item_border_color='' item_custom_tooltip_border='' link='' linktarget='' av_uid='' sc_version='1.0']
Zwei Online-Seminare, zwei Tagen Action-Training, E-Learning und individuelles Coaching: Du begibst dich in dieser Ausbildung auf eine herausfordernde und inspirierende Lernreise der persönlichen und beruflichen Weiterentwicklung „out of the comfort zone“.
[/av_icongrid_item]
[av_icongrid_item title='Warum ist es die effektivste Ausbildung auf dem Markt?' subtitle='' icon='ue80c' font='entypo-fontello' heading_tag='' heading_class='' item_font_color='' item_custom_icon='' item_custom_title='' item_custom_subtitle='' item_custom_content='' item_bg_color='' item_custom_front_bg_type='bg_color' item_custom_front_bg='' item_custom_front_gradient_color1='' item_custom_front_gradient_color2='' item_custom_front_gradient_direction='vertical' item_custom_back_bg_type='bg_color' item_custom_back_bg='' item_custom_back_gradient_color1='' item_custom_back_gradient_color2='' item_custom_back_gradient_direction='vertical' item_border_color='' item_custom_tooltip_border='' link='' linktarget='' av_uid='' sc_version='1.0']
Neben dem Input über die Online-Seminare trainierst du „real life“ Situationen: Du hast mit einem echten Team ein Unternehmen zu führen! Die fiktive Firma „All4Sports AG“ wandelt sich von einem hierarchisch organisierten zu einem agilen Unternehmen. Du gehst diesen Weg mit und trainierst so auf effektive Art und Weise die entscheidenden Kompetenzen im Umgang mit Wandel und Komplexität.
[/av_icongrid_item]
[/av_icongrid]
[/av_section]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='huge' custom_margin='0px' custom_margin_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' color='alternate_color' background='bg_color' custom_bg='#f8f9fa' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='ansatz' custom_class='' template_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0']
[av_one_fifth first av_uid='']

[/av_one_fifth][av_three_fifth av_uid='']

[av_heading heading='Der neue Leadership Ansatz' tag='h2' style='blockquote modern-quote modern-centered' subheading_active='' show_icon='' icon='ue800' font='entypo-fontello' size='30' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' subheading_size='15' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' icon_size='' av-medium-font-size-1='' av-small-font-size-1='' av-mini-font-size-1='' color='' custom_font='' subheading_color='' seperator_color='' icon_color='' margin='' margin_sync='true' padding='10' icon_padding='10' headline_padding='' headline_padding_sync='true' link='' link_target='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_heading]

[/av_three_fifth][av_one_fifth av_uid='']

[/av_one_fifth][av_one_fourth first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' min_col_height='' padding='25px' padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' border='' border_style='solid' border_color='' radius='' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='#ffffff' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="mt-0">Die Digitale Transformation schreitet voran</h3>
Aufgrund der Digitalen Transformation befinden sich heute viele Unternehmen im Wandel. Fast alle erleben sich in diesem Prozess in einem Spannungsfeld zwischen Hierarchie und Selbstorganisation: Einige Teams haben auf selbstorganisierte Arbeitsweisen umgestellt. Andere arbeiten - manchmal ganz bewusst - immer noch klassisch-hierarchisch. Häufig trifft man Mischformen an. Diese neue Realität führt zur entscheidenden Frage: Wie sieht denn heute erfolgreiche Führung aus?
[/av_textblock]

[/av_one_fourth][av_three_fourth av_uid='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>Situational Agile Leadership (S.A.L)</h3>
Insbesondere Führungskräfte und Menschen in Verantwortung müssen als 'Die Leistungsträger des Unternehmens' mit der neuen Situation gut umgehen können. Das dazu passende Konzept ist die situativ-agile Führung!
[/av_textblock]

[av_image src='http://fitforleadership.ch/lead-agile-onepage-2022/wp-content/uploads/2022/03/lead-agile-leadership-jongleur.jpg' attachment='591' attachment_size='full' copyright='' caption='' image_size='' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='fade-in' hover='' appearance='' link='' target='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
Bildlich gesprochen setzt die Führungskraft je nach Situation und Reifegrad des Mitarbeitenden die eine, die andere oder beide «Hände» ein:
<ul>
 	<li>Mit der einen Hand führt die Führungskraft klassisch transaktional: Sie vereinbart Ziele, delegiert Aufgaben, entscheidet klar und eindeutig, informiert stufengerecht und kontrolliert den Prozess und die Erreichung der Ziele.</li>
</ul>
<ul>
 	<li>Mit der anderen Hand führt sie agil transformational: Sie vermittelt Sinn, empowert, sorgt für zieledienliche Rahmenbedingungen, ermöglicht schnelle Umsetzung und entwickelt eine Feedbackkultur des gemeinsamen Lernens.</li>
</ul>
<h3>Situational Agile Leaderhip = Transaktional + Transformational führen</h3>
Situativ-agile Führung heisst, dass du als Führungskraft so flexibel sein musst, dass du je nach Unternehmenskontext und Reifegrad des Mitarbeitenden entweder transaktional oder transformational führst. Dies ist das Erfolgskonzept von Führungskräften und Unternehmen in Zeiten des Wandels!

<strong>Situational Agile Leadership (S.A.L) <sup>©</sup> </strong>ist ein geschützer Ansatz der LEAD Evolution GmbH. Mehr dazu unter <a href="https://creativecommons.org/licenses/by-nc-nd/4.0/deed.de">Creative Commons Schutzbereich.</a>
[/av_textblock]

[/av_three_fourth]
[/av_section]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='large' custom_margin='0px' custom_margin_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' color='main_color' background='bg_color' custom_bg='#9cb84c' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='portfolio' custom_class='' template_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0']
[av_one_fifth first av_uid='']

[/av_one_fifth][av_three_fifth av_uid='']

[av_heading heading='Zielgruppe, Fokus & Pain Points' tag='h2' style='blockquote modern-quote modern-centered' subheading_active='' show_icon='' icon='ue800' font='entypo-fontello' size='30' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' subheading_size='15' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' icon_size='' av-medium-font-size-1='' av-small-font-size-1='' av-mini-font-size-1='' color='custom-color-heading' custom_font='#ffffff' subheading_color='' seperator_color='' icon_color='' margin='' margin_sync='true' padding='10' icon_padding='10' headline_padding='' headline_padding_sync='true' link='' link_target='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_heading]

[/av_three_fifth][av_one_fifth av_uid='']

[/av_one_fifth][av_one_half first av_uid='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<div class="col-xl-6">
<h3 class="m-0 text-white font-size-25">Zielgruppe & Fokus</h3>
</div>
[/av_textblock]

[av_iconlist position='left' iconlist_styling='' custom_title_size='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' custom_title='#ffffff' custom_content='' color='ext_simple' custom_font='#e5b433' custom_bg='#ffffff' custom_border='' gradient_color_direction='vertical' gradient_color_1='#000000' gradient_color_2='#ffffff' gradient_color_3='' border='' border_width='' border_width_sync='true' border_color='' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' sonar_effect_effect='element_hover_perm' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' alb_description='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_iconlist_item title='Du möchtest als Führungskraft, Projektleiter:in bzw. Product Owner lernen, wie du sowohl in «klassischen» Teams als auch in Teams, die mit agilen Tools arbeiten, effektiv und erfolgreich führen kannst.' icon='ue8a3' font='entypo-fontello' heading_tag='' heading_class='' link='' linktarget='' linkelement='' av_uid='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Du möchtest als Führungskraft, Projektleiter:in bzw. Product Owner deine transaktionalen Führungsfähigkeiten wie «Ziele setzen», «Delegieren» und «klar Entscheiden» weiterentwickeln.' icon='ue8a3' font='entypo-fontello' heading_tag='' heading_class='' link='' linktarget='' linkelement='' av_uid='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='Du möchtest als Führungskraft, Projektleiter:in bzw. Product Owner deine transformationalen Führungsfähigkeiten, wie «Inspirieren», «Schnell und einfach umsetzen» und «Gemeinsam lernen» weiterentwickeln.' icon='ue8a3' font='entypo-fontello' heading_tag='' heading_class='' link='' linktarget='' linkelement='' av_uid='' sc_version='1.0'][/av_iconlist_item]
[/av_iconlist]

[/av_one_half][av_one_half av_uid='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' color='#ffffff' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 class="m-0 text-white font-size-25">Typische Pain Points</h3>
[/av_textblock]

[av_iconlist position='left' iconlist_styling='' custom_title_size='' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' custom_content_size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='custom' custom_title='#ffffff' custom_content='' color='ext_simple' custom_font='#e5b433' custom_bg='#ffffff' custom_border='' gradient_color_direction='vertical' gradient_color_1='#000000' gradient_color_2='#ffffff' gradient_color_3='' border='' border_width='' border_width_sync='true' border_color='' box_shadow='' box_shadow_style='0px,0px,0px,0px' box_shadow_color='' animation='' sonar_effect_effect='element_hover_perm' sonar_effect_color='' sonar_effect_duration='1' sonar_effect_scale='' sonar_effect_opac='0.5' alb_description='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_iconlist_item title='«Wie werde ich zum agilen Leader, was bedeutet ‘Growth Mindset’? Manchmal habe ich das Gefühl, dass ich auf einem guten Weg bin. Aber wie gelingt es die ‘Verweigerer’ mit ins Boot zu holen?»' icon='ue812' font='entypo-fontello' heading_tag='' heading_class='' link='' linktarget='' linkelement='' av_uid='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title='«Einerseits bin ich als Chef/in für mein Team verantwortlich, andererseits arbeite ich in Projekten mit anderen Führungskräften zusammen. Ich muss viel die Rolle switchen und fühle mich oft verunsichert.»' icon='ue812' font='entypo-fontello' heading_tag='' heading_class='' link='' linktarget='' linkelement='' av_uid='' sc_version='1.0'][/av_iconlist_item]
[av_iconlist_item title=' «Ich habe schon lange kein offenes und ehrliches Feedback auf mein Führungsverhalten bekommen. Wirke ich als Vorbild? Kommt meine Kommunikation an? Ich sehe mich nicht immer als ‘inspirierend’.»' icon='ue812' font='entypo-fontello' heading_tag='' heading_class='' link='' linktarget='' linkelement='' av_uid='' sc_version='1.0'][/av_iconlist_item]
[/av_iconlist]

[/av_one_half]
[/av_section]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='large' custom_margin='0px' custom_margin_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' color='main_color' background='bg_color' custom_bg='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='konzept' custom_class='' template_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0']
[av_one_fifth first av_uid='']

[/av_one_fifth][av_three_fifth av_uid='']

[av_heading heading='Was du in den 5 Tagen erlebst' tag='h2' style='blockquote modern-quote modern-centered' subheading_active='' show_icon='' icon='ue800' font='entypo-fontello' size='30' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' subheading_size='15' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' icon_size='' av-medium-font-size-1='' av-small-font-size-1='' av-mini-font-size-1='' color='' custom_font='' subheading_color='' seperator_color='' icon_color='' margin='' margin_sync='true' padding='10' icon_padding='10' headline_padding='' headline_padding_sync='true' link='' link_target='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_heading]

[/av_three_fifth][av_one_fifth av_uid='']

[/av_one_fifth][av_one_fifth first av_uid='']

[/av_one_fifth][av_three_fifth av_uid='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 style="text-align: center;">Innovatives Blended Learning Konzept</h3>
<p style="text-align: center;">Die Ausbildung Agile Leadership ist modular aufgebaut:</p>

<ul style="text-align: center;">
 	<li><strong>Zwei Live Online-Seminare</strong> «Agile Grundlagen»</li>
 	<li><strong>Zwei Tage Action Training</strong> «Wir führen die All4Sports AG!»</li>
 	<li><strong>Begleitendes E-Learning</strong> «Transfer»</li>
 	<li><strong>Individuelles Führungscoaching</strong> «Next Steps»</li>
</ul>
<p style="text-align: center;">Durch dieses innovative Blended Learning Konzept ist sichergestellt, dass Phasen des Erlebens mit Phasen des Reflektierens und Lernens abwechseln.</p>
[/av_textblock]

[/av_three_fifth][av_one_fifth av_uid='']

[/av_one_fifth][av_one_fourth first av_uid='']

[av_image src='http://fitforleadership.ch/lead-agile-onepage-2022/wp-content/uploads/2022/04/lead-agile-leadership-commitment-2.jpg' attachment='651' attachment_size='full' copyright='' caption='' image_size='' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='' target='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_one_fourth][av_one_fourth av_uid='']

[av_image src='http://fitforleadership.ch/lead-agile-onepage-2022/wp-content/uploads/2022/04/lead-agile-action-training-2.jpg' attachment='648' attachment_size='full' copyright='' caption='' image_size='' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='' target='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_one_fourth][av_one_fourth av_uid='']

[av_image src='http://fitforleadership.ch/lead-agile-onepage-2022/wp-content/uploads/2022/04/lead-agile-aufbau-festigung-2.jpg' attachment='649' attachment_size='full' copyright='' caption='' image_size='' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='' target='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_one_fourth][av_one_fourth av_uid='']

[av_image src='http://fitforleadership.ch/lead-agile-onepage-2022/wp-content/uploads/2022/04/lead-agile-coaching-2.jpg' attachment='650' attachment_size='full' copyright='' caption='' image_size='' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='' target='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[/av_one_fourth][av_one_half first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' min_col_height='' padding='30px,20px,20px,20px' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' border='1' border_style='solid' border_color='#e2e2e2' radius='3px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='#f9f9f9' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_image src='http://fitforleadership.ch/lead-agile-onepage-2022/wp-content/uploads/2022/03/1-icon-80x80.png' attachment='599' attachment_size='thumbnail' copyright='' caption='' image_size='' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='' target='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>A. Der Start: 2 x Live Online Seminare «Agile Grundlagen»</h3>
In zwei Live Online-Seminartagen lernst du die Grundlagen der agilen Führung. Folgende in der Praxis bewährten Konzepte sind dabei von zentraler Bedeutung:
<ul>
 	<li>VUCA Zeiten – Start with the Why</li>
 	<li>Growth Mindset des Lernens</li>
 	<li>Grundprinzipien der Agilen Methoden</li>
 	<li>Konzept der «situativ-agilen, beidhändigen Führung</li>
</ul>
Die beiden Seminartage enden mit dem Check des eigenen Führungsprofils und der damit verbundenen Einordnung der persönlichen Lernfelder.
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' min_col_height='' padding='30px,20px,20px,20px' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' border='1' border_style='solid' border_color='#e2e2e2' radius='3px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='#f9f9f9' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_image src='http://fitforleadership.ch/lead-agile-onepage-2022/wp-content/uploads/2022/03/2-icon-80x80.png' attachment='615' attachment_size='thumbnail' copyright='' caption='' image_size='' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='' target='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>B. Zwei Tage Praxis-Check «Wir führen die All4Sports AG»!</h3>
Nach den Live Online-Seminaren folgt der Praxis-Check: Du erlebst zwei Tage Action Training in der Übungsfirma All4Sports AG – Ein Unternehmen zwischen klassisch und agil. In einem realitätsnahen Setting erlebst du in echten Teams den ganz normalen Alltagswahnsinn: Knappe Ressourcen, widersprüchliche Ziele, ungeplante Störungen, turbulente Zeiten. Wie das «wirkliche Leben», nur im Zeitraffer.

Die All4Sports AG startet in einem klassisch-hierarchischen Führungssystem, welches sich in den zwei Tagen zur Selbstorganisation wandelt. Der Unterschied zum Alltag ist, dass du in aller Ruhe reflektieren kannst, was bei diesem Wandel mit dir und deiner Rolle passiert. So kannst du die neuen Herausforderungen praktisch trainieren und dich in «geschützter Umgebung» ausprobieren.
[/av_textblock]

[/av_one_half][av_one_half first min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' min_col_height='' padding='30px,20px,20px,20px' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' border='1' border_style='solid' border_color='#e2e2e2' radius='3px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='#f9f9f9' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_image src='http://fitforleadership.ch/lead-agile-onepage-2022/wp-content/uploads/2022/03/3-icon-80x80.png' attachment='616' attachment_size='thumbnail' copyright='' caption='' image_size='' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='' target='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>C. Der Transfer: E-Learning «Festigung des Gelernten»</h3>
Nach dem 2-tägigen «Action Training» erhältst du 8 Wochen lang in der PEAQ Learning Cloud inspirierenden Input und arbeitest an deinen Themen weiter. Lernen findet überall statt: Ob abends am PC, unterwegs auf dem Smartphone oder über den Mittag: Du setzt dich intensiv mit deinen «Learnings» auseinander.

Zwischendurch kommst du mit den anderen teilnehmenden Führungskräften online zusammen, und reflektierst mit den Coaches die auftauchenden Führungsfragen und Herausforderungen.
[/av_textblock]

[/av_one_half][av_one_half min_height='' vertical_alignment='av-align-top' space='' row_boxshadow_color='' row_boxshadow_width='10' margin='0px' margin_sync='true' mobile_breaking='' min_col_height='' padding='30px' padding_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' border='1' border_style='solid' border_color='#e2e2e2' radius='3px' radius_sync='true' column_boxshadow_color='' column_boxshadow_width='10' background='bg_color' background_color='#f9f9f9' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' background_position='top left' background_repeat='no-repeat' highlight_size='1.1' animation='' link='' linktarget='' link_hover='' title_attr='' alt_attr='' mobile_display='' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0']

[av_image src='http://fitforleadership.ch/lead-agile-onepage-2022/wp-content/uploads/2022/03/4-icon-80x80.png' attachment='617' attachment_size='thumbnail' copyright='' caption='' image_size='' styling='' align='center' font_size='' overlay_opacity='0.4' overlay_color='#000000' overlay_text_color='#ffffff' animation='no-animation' hover='av-hover-grow' appearance='' link='' target='' title_attr='' alt_attr='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_image]

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3>D. Die Weiterentwicklung: Führungscoaching «Next Steps»</h3>
Die am Schluss des 2-tägigen Action Trainings präsentierten persönlichen Lernziele werden aufgenommen und im Coaching gemeinsam geprüft, wie die Umsetzung in die Praxis gelungen ist. So kann nochmals «nachjustiert» werden.

Der ganze Lernprozess wird durch dieses Coaching signifikant verstärkt, die persönliche Entwicklung wird auf den Punkt gebracht und weitere zieldienliche Schritte werden initiiert. Im persönlichen Gespräch bleibt auch Raum und Zeit, gemeinsam die aktuellen Führungsfragen zu reflektieren.
[/av_textblock]

[/av_one_half][av_one_fifth first av_uid='']

[/av_one_fifth][av_three_fifth av_uid='']

[av_textblock size='' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' font_color='' color='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
<h3 style="color: #f6c84e;"><strong>Dein Abschluss: Certified Agile Leader/in</strong></h3>
Mit deinem Zertifikat «Certified Agile Leader/in» der PEAQ Academy weist du gefragte Kompetenzen nach, die heutzutage in vielen Unternehmen relevant sind. So verbesserst du nicht nur deine aktuellen Führungsfähigkeiten, sondern erhöhst nachhaltig deine Chancen am Arbeitsmarkt.
[/av_textblock]

[/av_three_fifth][av_one_fifth av_uid='']

[/av_one_fifth]
[/av_section]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='large' custom_margin='0px' custom_margin_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' color='main_color' background='bg_color' custom_bg='#e0b13a' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='portfolio' custom_class='' template_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0']
[av_one_fifth first av_uid='']

[/av_one_fifth][av_three_fifth av_uid='']

[av_heading heading='Impressionen ' tag='h2' style='blockquote modern-quote modern-centered' subheading_active='' show_icon='' icon='ue800' font='entypo-fontello' size='30' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' subheading_size='15' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' icon_size='' av-medium-font-size-1='' av-small-font-size-1='' av-mini-font-size-1='' color='custom-color-heading' custom_font='#ffffff' subheading_color='' seperator_color='' icon_color='' margin='' margin_sync='true' padding='10' icon_padding='10' headline_padding='' headline_padding_sync='true' link='' link_target='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_heading]

[/av_three_fifth][av_one_fifth av_uid='']

[/av_one_fifth][av_one_full first av_uid='']

[av_horizontal_gallery ids='492,491,490' height='25' size='large' gap='large' active='enlarge' initial='' control_layout='av-control-default' links='active' link_dest='' lightbox_text='no_text' img_scrset='' lazy_loading='enabled' id='' custom_class='' template_class='' av_uid='' sc_version='1.0'][/av_horizontal_gallery]

[/av_one_full]
[/av_section]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='default' custom_margin='0px' custom_margin_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' color='main_color' background='bg_color' custom_bg='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='programm' custom_class='' template_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0']
[av_one_fifth first av_uid='']

[/av_one_fifth][av_three_fifth av_uid='']

[av_heading heading='Programm, Konzept, Organisation ' tag='h2' style='blockquote modern-quote modern-centered' subheading_active='' show_icon='' icon='ue800' font='entypo-fontello' size='30' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' subheading_size='15' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' icon_size='' av-medium-font-size-1='' av-small-font-size-1='' av-mini-font-size-1='' color='' custom_font='#ffffff' subheading_color='' seperator_color='' icon_color='' margin='' margin_sync='true' padding='10' icon_padding='10' headline_padding='' headline_padding_sync='true' link='' link_target='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_heading]

[/av_three_fifth][av_one_fifth av_uid='']

[/av_one_fifth][av_one_full first av_uid='']

[av_tab_container initial='1' position='top_tab' boxed='border_tabs' alb_description='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0']
[av_tab title='Programm' icon_select='no' icon='ue800' font='entypo-fontello' custom_id='' av_uid='' sc_version='1.0']
<h3>A. Führungsausbildung «Certified Agile Leader» (4 Module, 5 Tage)</h3>
<strong>Modul 1 - Der Start «Agile Grundlagen»</strong>
<ul>
 	<li>Live Online Seminar «VUCA Zeiten - Start with the Why» & «Das Growth Mindset»</li>
 	<li>Live Online Seminar «Agile Grundprinzipien», «Situativ agile Führung»</li>
 	<li>Leadership-Check: Profil, Stärken, Lernfelder</li>
</ul>
<strong>Modul 2 - Die Praxis «Wir führen die All4Sports AG»</strong>
<ul>
 	<li>2 Tage All4Sports AG - Ein Unternehmen im Wandel</li>
 	<li>4 Szenarien: Von klassischer Hierarchie bis Selbstorganisation</li>
</ul>
<strong>Modul 3 - Der Transfer «Festigung des Gelernten»</strong>
<ul>
 	<li>Vertiefung des Gelernten mit E-Learning</li>
 	<li>Online Workshop «Begleitung im Alltag»</li>
</ul>
<strong>Modul 4 - Die Weiterentwicklung «Next Steps»</strong>
<ul>
 	<li>Persönliches Coaching «Aktuelle Herausforderungen»</li>
 	<li>Meine persönlichen Wachstumsfelder</li>
</ul>
<h3>B. Führungsthemen, die bearbeitet werden</h3>
<ul>
 	<li>Führen im hierarchischen Umfeld - Führen im agilen Umfeld</li>
 	<li>Remote Leadership - Führen von hybriden Teams</li>
 	<li>Unterschiedliche Mitarbeitende situativ richtig führen</li>
</ul>
<ul>
 	<li>Innovation treiben, gleichzeitig das Tagesgeschäft umsetzen</li>
 	<li>Umgang mit unklaren Aufgaben und wechselnden Zielsetzung</li>
 	<li>Trotz knapper Ressourcen, hohe Ziele erreichen</li>
</ul>
<ul>
 	<li>Schwierige Gespräche führen</li>
 	<li>Konflikte im Team managen</li>
 	<li>Umgang mit Störungen von Aussen</li>
</ul>
<ul>
 	<li>Überzeugend Auftreten und Präsentieren</li>
 	<li>Kritik souverän begegnen</li>
 	<li>Sich selbst und die Arbeitsergebnisse richtig verkaufen</li>
</ul>
<h3>C. Zertifikat «Certified Situational Agile Leader»</h3>
Die Führungsausbildung Agile Leadership führt zum Zertifikat «Agile Leader» der PEAQ Academy. Damit weist du gefragte Kompetenzen nach, die heutzutage in vielen Unternehmen relevant sind. So verbesserst du nicht nur deine aktuellen Führungsfähigkeiten, sondern erhöhst nachhaltig deine Chancen am Arbeitsmarkt.
[/av_tab]
[av_tab title='Idee & Konzept' icon_select='no' icon='ue800' font='entypo-fontello' custom_id='' av_uid='' sc_version='1.0']
<h3>Agile Führung muss man auch agil trainieren!</h3>
Wie lernt man «Agile Leadership? Nicht durch Bücher lesen, nicht an der Uni und nicht im 08/15 Seminar! Der Königsweg ist die simulierte Praxis. Die Teilnehmenden erkennen hier viele Situationen aus ihrem Alltag wieder und finden Antwort auf Fragen, die sie schon länger beschäftigen.

Diese simulierte Praxis ist fast so lebensecht wie das richtige Leben, aber Fehler schmerzen deutlich weniger. Und: Die Lernkurve ist viel steiler als an herkömmlichen Seminarveranstaltungen!

Mit dem konsequenten Blended-Learning-Ansatz wird Präsenz mit Online kombiniert. Live Online-Seminare, Action Training, E-Learning und Einzelcoaching: So gelingt es, das Beste aus allen Lernwelten zu realisieren.
[/av_tab]
[av_tab title='Ort, Daten & Investition' icon_select='no' icon='ue800' font='entypo-fontello' custom_id='' av_uid='' sc_version='1.0']
<h3>Ausbildung «Certified Situational Agile Leader» (4 Module, 5 Tage)</h3>
<strong>Modul 1 Der Start «Agile Grundlagen»</strong>
<ul>
 	<li>Live Online Seminar «VUCA Zeiten - Start with the Why» & «Das Growth Mindset»</li>
 	<li>Live Online Seminar «Agile Grundprinzipien», «Situativ agile Führung»</li>
</ul>
Check: Mein Leadership Profil, meine Stärken und Lernfelder
<h3>Modul 2 Die Praxis «Wir führen die All4Sports AG»</h3>
<ul>
 	<li>2 Tage Action Training in der All4Sports AG</li>
 	<li>4 Szenarien: Von klassischer Hierarchie bis Selbstorganisation</li>
</ul>
<h3>Modul 3 Der Transfer «Festigung des Gelernten»</h3>
<ul>
 	<li>Vertiefung des Gelernten mit E-Learning</li>
 	<li>Online Workshop «Begleitung im Alltag»</li>
</ul>
<h3>Modul 4 Die Weiterentwicklung «Next Steps»</h3>
<ul>
 	<li>Persönliches Coaching «Aktuelle Herausforderungen»</li>
 	<li>Meine persönlichen Wachstumsfelder</li>
</ul>
<h3>Anmeldung, Teilnahme, Investition</h3>
Aus Qualitätsgründen ist die Teilnehmerzahl strikt auf 15 Personen beschränkt. Eine frühzeitige Anmeldung wird deshalb empfohlen. Nach der Anmeldung erhältst du umgehend eine Bestätigung mit allen weiteren Details! Alle Kursmaterialien, Tagungspauschale und Mittagessen sind inkludiert.

<strong>Deine Investition:</strong> CHF 3990 / EUR 3700
[/av_tab]
[/av_tab_container]

[/av_one_full]
[/av_section]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='large' custom_margin='0px' custom_margin_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' color='main_color' background='bg_color' custom_bg='#9cb84c' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='programm' custom_class='' template_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0']
[av_one_fifth first av_uid='']

[/av_one_fifth][av_three_fifth av_uid='']

[av_heading heading='Teilnehmerstimmen' tag='h2' style='blockquote modern-quote modern-centered' subheading_active='' show_icon='' icon='ue800' font='entypo-fontello' size='30' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' subheading_size='15' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' icon_size='' av-medium-font-size-1='' av-small-font-size-1='' av-mini-font-size-1='' color='custom-color-heading' custom_font='#ffffff' subheading_color='' seperator_color='' icon_color='' margin='' margin_sync='true' padding='10' icon_padding='10' headline_padding='' headline_padding_sync='true' link='' link_target='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_heading]

[/av_three_fifth][av_one_fifth av_uid='']

[/av_one_fifth][av_one_full first av_uid='']

[av_testimonials style='slider_large' columns='2' grid_style='' font_color='custom' custom_title='#e2e2e2' custom_sub='' custom_content='#ffffff' interval='5' alb_description='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_testimonial_single src='' name='' subtitle='' link='http://' linktext='' av_uid='' sc_version='1.0']
<em>«Die Führungsausbildung Agile Leadership besticht durch einen hoch effektiven Blended-Learning Ansatz des iterativen Lernens. So macht Lernen Spass!»</em>
[/av_testimonial_single]
[av_testimonial_single src='' name='' subtitle='' link='http://' linktext='' av_uid='' sc_version='1.0']
<em>«Die Führungsausbildung «Certified Agile Leader» ist modular aufgebaut: Online Live Seminare, Action Training vor Ort, E-Learning und 1to1 Coaching a.»</em>
[/av_testimonial_single]
[av_testimonial_single src='' name='Mike B., Teamleiter' subtitle='' link='http://' linktext='' av_uid='' sc_version='1.0']
<em>«…die Ausbildung hat mich als Führungskraft und als Persönlichkeit entscheidend weitergebracht!»</em>
[/av_testimonial_single]
[/av_testimonials]

[/av_one_full]
[/av_section]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='large' custom_margin='0px' custom_margin_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' color='main_color' background='bg_color' custom_bg='' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='' custom_class='' template_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0']
[av_one_fifth first av_uid='']

[/av_one_fifth][av_three_fifth av_uid='']

[av_heading heading='Dein Trainerteam' tag='h2' style='blockquote modern-quote modern-centered' subheading_active='' show_icon='' icon='ue800' font='entypo-fontello' size='30' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' subheading_size='15' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' icon_size='' av-medium-font-size-1='' av-small-font-size-1='' av-mini-font-size-1='' color='custom-color-heading' custom_font='' subheading_color='' seperator_color='' icon_color='' margin='' margin_sync='true' padding='10' icon_padding='10' headline_padding='' headline_padding_sync='true' link='' link_target='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_heading]

[/av_three_fifth][av_one_fifth av_uid='']

[/av_one_fifth][av_one_half first av_uid='']

[av_team_member name='David Kaspar' job='Executive Coach, Founder & C.E.O. PEAQ' src='http://fitforleadership.ch/lead-agile-onepage-2022/wp-content/uploads/2022/04/david-caspar-lead-agile.jpg' attachment='659' attachment_size='full' image_width='' description='' font_color='' custom_title='' custom_content='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_team_member]

[av_toggle_container faq_markup='' initial='0' mode='accordion' sort='' styling='av-minimal-toggle' colors='custom' font_color='#ffffff' background_color='#e0b13a' border_color='' toggle_icon_color='' colors_current='' font_color_current='' toggle_icon_color_current='' background_current='' background_color_current='' background_gradient_current_direction='vertical' background_gradient_current_color1='#000000' background_gradient_current_color2='#ffffff' background_gradient_current_color3='' hover_colors='' hover_font_color='' hover_background_color='' hover_toggle_icon_color='' alb_description='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_toggle title='Profil' tags='' custom_id='' av_uid='' sc_version='1.0']
<strong>«Man kann nicht dem Wind befehlen - Aber man kann Segel setzen!»</strong>

<strong>Faszination</strong>
Neben seiner Tätigkeit als Coach & Sparringpartner von Unternehmer:innen und (Top-) Manager:innen ist David an vier Firmen als Investor & Partner beteiligt und führt diese zusammen mit seinen Geschäftspartnern. Mit «PEAQ» gehört er selbst zu den «Digitalen Pionieren» im Markt und setzte eine innovative Plattform-Idee erfolgreich in die Praxis um.

Die verschiedenen Rollen mit den daraus gewonnen unterschiedlichen Perspektiven faszinieren ihn und zeichnet die Qualität seiner Arbeit aus!

<strong>Werdegang und Expertise</strong>
Zusätzlich zu seinem Studium der Rechte investierte David parallel zu diversen Coaching- und Trainingsausbildungen Zeit in ein postgraduales 5-semestriges «Coaching-orientierten Studium» in Psychologie, Philosophie, BWL und Negotiation (Uni Bern, Hochschule St. Gallen, HSG, Harvard University).

<strong>Persönliches</strong>
David ist verheiratet, hat 2 Kinder, ist begeisterter Bergsteiger, liebt Käse, Whisky und Wein (Somelier Maître Fromager), liest viel, lacht gerne, joggt nur aus Vernunftgründen und praktiziert mit großer Faszination seit über 10 Jahren täglich Zen.
[/av_toggle]
[/av_toggle_container]

[/av_one_half][av_one_half av_uid='']

[av_team_member name='Alexander Benedix' job='Führungskräftetrainer, Podcaster ' src='http://fitforleadership.ch/lead-agile-onepage-2022/wp-content/uploads/2022/04/alexander-benedix-lead-agile-2.jpg' attachment='638' attachment_size='full' image_width='' description='' font_color='' custom_title='' custom_content='' img_scrset='' lazy_loading='disabled' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg=''][/av_team_member]

[av_toggle_container faq_markup='' initial='0' mode='accordion' sort='' styling='av-minimal-toggle' colors='custom' font_color='#ffffff' background_color='#e0b13a' border_color='' toggle_icon_color='' colors_current='' font_color_current='' toggle_icon_color_current='' background_current='' background_color_current='' background_gradient_current_direction='vertical' background_gradient_current_color1='#000000' background_gradient_current_color2='#ffffff' background_gradient_current_color3='' hover_colors='' hover_font_color='' hover_background_color='' hover_toggle_icon_color='' alb_description='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_toggle title='Profil' tags='' custom_id='' av_uid='' sc_version='1.0']
<strong>«Es gibt mehr Leute, die kapitulieren, als solche, die scheitern!»</strong>

<strong>Faszination</strong>
Alexander verfügt über mehr als 20 Jahre praktische Erfahrung als Führungskraft und Leadership Trainer. Er ist Fan von agilen Denk- und Arbeitsweisen, jedoch ist “Agilität” für ihn weder die Lösung für alle Probleme noch passen agile Methoden zu allen Mitarbeitenden. Deswegen berichtet Alexander auch offen darüber, was in der agilen und der klassischen Führungswelt funktioniert und was eben nicht.

Seine Veranstaltungen haben alle einen hohen Praxis- und vor allem Übungsanteil und fördern Eigenverantwortung und Selbstorganisation aller Beteiligten. Mit seinem Leadership Podcast «Führung kann so einfach sein» ist Alexander Dauergast in den Top 25 der Apple Charts.

<strong>Werdegang und Expertise</strong>
Nach seinem Studium absolvierte Alexander eine einjährige Vollzeitausbildung zum Personal- und Organisationsentwickler inkl. Trainerausbildung. Zunächst sammelte er mehrjährige praktische Erfahrung als Führungskraft, Projektleiter und Personalentwickler in einem internationalen Konzern bevor er als Länder-Geschäftsführer eines digitalen StartUps mit agilen Methoden und Arbeitsweisen in Kontakt kam.

Alexander versteht es die agile und klassische Führungswelt miteinander zu verbinden und praxiserprobte Do`s and Dont`s für den Führungsalltag unterhaltsam zu vermitteln.

<strong>Persönliches</strong>
Alexander hat auf Reisen immer Musik und Kopfhörer dabei, singt als Bass im Chor und mag Asia-Food. Er hat alle Bücher von Game of Thrones gelesen, geht regelmässig zum Fitness und holt sich mit seinem Mountainbike die Action in den Wäldern am Bodensee.
[/av_toggle]
[/av_toggle_container]

[/av_one_half]
[/av_section]

[av_section min_height='' min_height_pc='25' min_height_px='500px' padding='large' custom_margin='0px' custom_margin_sync='true' svg_div_top='' svg_div_top_color='#333333' svg_div_top_width='100' svg_div_top_height='50' svg_div_top_max_height='none' svg_div_top_opacity='' svg_div_bottom='' svg_div_bottom_color='#333333' svg_div_bottom_width='100' svg_div_bottom_height='50' svg_div_bottom_max_height='none' svg_div_bottom_opacity='' color='main_color' background='bg_color' custom_bg='#9cb84c' background_gradient_direction='vertical' background_gradient_color1='#000000' background_gradient_color2='#ffffff' background_gradient_color3='' src='' attachment='' attachment_size='' attach='scroll' position='top left' repeat='no-repeat' video='' video_ratio='16:9' overlay_opacity='0.5' overlay_color='' overlay_pattern='' overlay_custom_pattern='' shadow='no-border-styling' bottom_border='no-border-styling' bottom_border_diagonal_color='#333333' bottom_border_diagonal_direction='' bottom_border_style='' custom_arrow_bg='' id='kontakt' custom_class='' template_class='' aria_label='' av_element_hidden_in_editor='0' av_uid='' sc_version='1.0']
[av_one_full first av_uid='']

[av_heading heading='Kontakt & Buchung: Sichere dir deinen Platz!' tag='h2' style='blockquote modern-quote modern-centered' subheading_active='subheading_below' show_icon='' icon='ue800' font='entypo-fontello' size='30' av-medium-font-size-title='' av-small-font-size-title='' av-mini-font-size-title='' subheading_size='15' av-medium-font-size='' av-small-font-size='' av-mini-font-size='' icon_size='' av-medium-font-size-1='' av-small-font-size-1='' av-mini-font-size-1='' color='custom-color-heading' custom_font='#ffffff' subheading_color='' seperator_color='' icon_color='' margin='' margin_sync='true' padding='10' icon_padding='10' headline_padding='' headline_padding_sync='true' link='' link_target='' id='' custom_class='' template_class='' av_uid='' sc_version='1.0' admin_preview_bg='']
Ausbildung Certified Agile Leadership
[/av_heading]

[/av_one_full][av_one_full first av_uid='']

[av_contact title='' button='Buchung oder Terminanfrage absenden' on_send='' sent='Vielen Dank, Ihre Buchung wurde an uns abgeschickt. Wir melden uns für die weitere Abwicklung.' link='manually,http://' captcha='' captcha_theme='light' captcha_size='normal' captcha_score='0.5' email='' from_email='' subject='' autoresponder_email='info@danielablei.de' autoresponder_reply_to='' autoresponder_subject='' autorespond='' autorespond_after='' hide_labels='aviaTBhide_labels' form_align='' color='av-custom-form-color av-light-form' heading_tag='' heading_class='' alb_description='' id='' custom_class='' template_class='' aria_label='' av_uid='' sc_version='1.0' admin_preview_bg='']
[av_contact_field label=' Direkt buchen – LEAD AGILE ACADEMY – FÜR DICH PERSÖNLICH' type='checkbox' options='Direkt buchen – Open LEAD,Termin für Präsentation «LEAD vorstellen» vereinbaren – LEAD Inhouse' check='' width='element_third' av_uid='' sc_version='1.0' multi_select='' av_contact_preselect=''][/av_contact_field]
[av_contact_field label=' Direkt buchen – LEAD AGILE INHOUSE – FÜR DEIN UNTERNEHMEN' type='checkbox' options='Direkt buchen – Open LEAD,Termin für Präsentation «LEAD vorstellen» vereinbaren – LEAD Inhouse' check='' width='element_third' av_uid='' sc_version='1.0' multi_select='' av_contact_preselect=''][/av_contact_field]
[av_contact_field label='Termin für Präsentation «LEAD vorstellen» vereinbaren – LEAD INHOUSE' type='checkbox' options='Direkt buchen – Open LEAD,Termin für Präsentation «LEAD vorstellen» vereinbaren – LEAD Inhouse' check='' width='element_third' av_uid='' sc_version='1.0'][/av_contact_field]
[av_contact_field label='Name' type='text' options='' check='is_empty' width='element_half' av_uid='' multi_select='' av_contact_preselect='' sc_version='1.0'][/av_contact_field]
[av_contact_field label='E-Mail' type='text' options='' check='is_email' width='element_half' av_uid='' multi_select='' av_contact_preselect='' sc_version='1.0'][/av_contact_field]
[av_contact_field label='Telefon' type='text' options='' check='is_phone' width='' av_uid='' sc_version='1.0' multi_select='' av_contact_preselect=''][/av_contact_field]
[av_contact_field label='Nachricht' type='textarea' options='' check='' width='' av_uid='' sc_version='1.0' multi_select='' av_contact_preselect=''][/av_contact_field]
[/av_contact]

[/av_one_full]
[/av_section]";}