Skip to main content

A Global Standard for TYPO3 Certifications

The TYPO3 Certification Team is committed to the development of a global standard for TYPO3 certifications. The certification program verifies the knowledge of the certified and the organizations employing them. The exams consist of multiple steps, each requiring different expertise.

A Collaboration between the Certification and the Education Team provides learning materials to support the certification candidates.

Syllabus

A TYPO3 CMS Certified Developer has to have experience collected through projects, should know the architecture, design patterns, best practices, and a fair share of internals both TYPO3 CMS and the extension framework. TYPO3 CMS Certified Developer can implement an extension completely in a state-of-the-art way. They write clean code by following the TYPO3 Coding Guidelines (CGL), and they are well versed in a wide range of topics, from the initial setup of an extension up to the point of publishing it in the TYPO3 Extension Repository (TER).

This SkillSet is based on TYPO3 version 12 LTS and was created by the TYPO3 Education Committee.

  • What is MVC?

    The MVC pattern, what it can be used for, and common implementations.

    Goals
    • I have a basic understanding of what MVC is.

  • What is a Templating Engine?

    Introduction to the basic concept of a templating engine/processor.

    Goals
    • I can explain what the basic concept of a templating engine is. 
    • I can identify needed parts for a templating engine. 

  • PSR Standards

    Knowing the most important PSR programming standards in the TYPO3 world.

    Goals
    • I know what PSR is.
    • I know the topics the most important standards cover.

  • Domain-Driven Design (DDD)

    Understanding the concept of DDD.

    Goals
    • I know the concept, its purposes and main points.
    • I know where to find information to learn more.

  • PHP

    Ability to develop and execute PHP scripts.

    Goals
    • I know how to execute PHP scripts in my local environment.
    • I know how PHP is executed by a web server.
    • I can develop functionality in PHP.

  • Model

    This skill covers the model in the MVC context.

    Goals
    • I know which role models play in the software architectural pattern MVC.

  • View Pattern

    What is a view in MVC context.

    Goals
    • I know which role the view plays in the pattern.

  • PSR-14: Event Dispatching

    This skill covers the basics of the PHP standard on Event dispatching.

    Goals
    • I know the four use cases of events specified by PSR-14.
    • I know about the different components of a PSR-14-compliant event system (Listener, Emitter, Dispatcher, ListenerProvider).
    • I know when mutable or immutable events should be used.

  • Dependency Injection

    Knowledge about dependency injection in general.

    Goals
    • I understand the concept of dependency injection, its benefits and limitations.
    • I know when dependency injection should be used.

  • The builder design pattern in TYPO3

    TYPO3 provides some concrete classes following the Builder design pattern.

    Goals
    • I know the different TYPO3 builder implementations.
    • I can use the different TYPO3 builder implementations.

  • Builder design pattern

    Understanding the “Builder” Design Pattern.

    Goals
    • I know the Builder Pattern and what it entails.
    • I know how to retrieve or create new instances of a builder.
    • I know how to re-use and not re-use builder instances.

  • Software Design Patterns

    This skill covers Software Design Patterns, established solutions for repeated problems in software development.

    Goals
    • I know what Design Patterns are and why they are useful
    • I know examples of Design Patterns used in TYPO3
    • I know when to apply Design Patterns in my own code

  • What is Fluid?

    Definition of Fluid and its possible use with regards to the Model View Controller pattern.

    Goals
    • I can explain what Fluid is. 
    • I can define its role in the context of a MVC system. 

  • Outputting Variables

    Basic usage of variables inside Fluid templates and knowledge about escaping.

    Goals
    • I can find out which variables are passed to a Fluid view.
    • I can output variables with the according path syntax.
    • I know how Fluid escapes variable output in templates.
    • I know how to disable escaping of variables.
    • I also know which security risks (XSS) may occure, when disable escaping of variables.

  • ViewHelpers

    Getting to know what a ViewHelper is.

    Goals
    • I know what ViewHelpers are.
    • I know what a Namespace is.
    • I can use ViewHelpers in my template.
    • I know which ViewHelpers are shipped by stand-alone Fluid, and which are provided by TYPO3 CMS.

  • Templates, Layouts, Partials

    Fluid Templates, Layouts, Partials - their interaction and properties.

    Goals

    I know

    • what Fluid Templates are
    • what Fluid Layouts are
    • what Fluid Partials are
    • how Templates, Layouts and Partials are connected

    I can

    • structure Templates, Layouts and Partials
    • combine Templates, Layouts and Partials for templating
    • use Templates, Layouts and Partials to realise a specific template example

  • ViewHelper: Comment

    Including comments in Fluid templates.

    Goals
    • I know how to include Fluid comments in my templates.
    • I know the difference between HTML comments and Fluid comments regarding the rendered HTML output.

  • ViewHelper: If/Else

    Creating if/else statements within Fluid templates.

    Goals
    • I can create an if/else statement in my templates with the help of the according Fluid ViewHelper.
    • I can apply conditions using the inline notation of Fluid.

  • ViewHelper: For-Loop

    Iterating through a list with the for ViewHelper.

    Goals
    • I know how to cycle through items with the help of the for ViewHelper inside my Fluid templates.
    • I also know how to utilize the iteration object within a cycle.

  • Importing ViewHelpers

    Using third party ViewHelpers in your Fluid templates.

    Goals
    • I can include third party ViewHelpers in my Fluid templates.
    • I know that a TYPO3 Developer can build custom ViewHelpers

  • ViewHelper: Render

    Using f:render to render sections and partials as well as passing arguments.

    Goals
    • I can use f:render in my templates to render sections and partials.
    • I can pass arguments (along with optional flagging).

  • Using the Fluid View

    Knowing and understanding the different parts of a Fluid template view.

    Goals
    • I understand the API of a Fluid view. 
    • I know the public methods that assign variables and template paths. 
    • I know the internal API to configure Fluid behaviour. 
    • I know the action of rendering a template. 

  • ViewHelper: Link, Uri

    Using the Fluid ViewHelpers f:link.* and f:uri.*.

    Goals
    • I know the ViewHelpers of the f:link.* family such as f:link.typolink, f:link.email etc. and their important arguments.
    • I know the ViewHelpers of the f:uri.* family and their important arguments.
    • I know how to use the f:link.* and f:uri.* ViewHelpers properly.

  • ViewHelper: Format

    Using Fluid Format ViewHelpers.

    Goals
    • I know how to use Fluid's format ViewHelper and its arguments and purposes.

  • ViewHelper: Image

    Using the Fluid ViewHelper f:image().

    Goals
    • I know the important arguments of f:image() ViewHelper (image, src, crop, cropVariant, loading) and how to use the ViewHelper.

  • JSON

    The JSON format and its usages in web development.

    Goals
    • I know how to decode JSON with PHP functions.
    • I know how to create a valid JSON string with PHP functions.

  • Extbase JSON View

    The built-in JSON View in Extbase.

    Goals
    • I know how the JSON view differs from a normal HTML-based view.
    • I know how the JSON view works when the data structure parts are selected for rendering.
    • I can configure the JSON output for simple and complex (nested) data structures.

  • Extbase Fluid View

    The Fluid-based HTML view of Extbase.

    Goals
    • I know how the Fluid view relates to Fluid.
    • I can use layouts and partials in my templates.
    • I can configure the view to include templates from multiple directories, with correct priority.

  • ViewHelper: Debug

    Utilising output to access Fluid variables.

    Goals
    • I know how to use the debug ViewHelper to output variables available to Fluid.
    • I know what makes this ViewHelper more appropriate than using a simple echo in my controller.

  • ViewHelper: Form

    The TYPO3 CMS form ViewHelper for Fluid.

    Goals
    • I know how Extbase forms can be created in Fluid templates.
    • I know how data can be filled into form fields.
    • I know how to connect object properties and form fields.
    • I can create a form and connect it to an object.
    • I can use the different view helpers to create form fields.
    • I know how Extbase ensures that no additional fields are passed by malicious actors.

  • Building data processors

    This skill covers the creation of data processors for TYPO3.

    Goals
    • I know how to implement a data processor.
    • I know how to alias a data processor.
    • I know how to support `stdWrap` for data processor properties.
    • I know how to execute data processors, e.g. for nesting.

  • XLIFF / locallang.xlf

    Working with XLIFF files in TYPO3 for multilingual websites. Includes writing and extending XLIFF files, overriding translations in TypoScript, and using the f:translate ViewHelper.

    Goals
    • I know what XLIFF is.
    • I know how to write and extend an XLIFF file.
    • I know how to introduce new languages and generate the needed XLIFF file.
    • I know how to override the translations of an extension in TypoScript.
    • I know how to access the translations with the f:translate-Viewhelper

  • File abstraction layer (FAL)

    Know about transparent inclusion of external file sources into TYPO3.

    Goals
    • I know there is an abstraction layer between actual file storages and their handling in TYPO3.

  • Flexform Concepts

    Basics about the concept of Flexforms and how it relates to the TCA.

    Goals
    • I know what a Flexform data structure is and how it compares to a similar TCA data structure.
    • I know how data for a Flexform field is stored.
    • I can create a Flexform data structure in XML.
    • I can configure a Flexform field to use my XML data structure.

  • Flexform Configuration Data Structure

    How to create and configure a data structure for my plugin’s configuration.

    Goals
    • I know how configuration is managed by the “plugin” content type.
    • I can provide a custom configuration data structure for my plugin.

  • Accessing FlexForm Data

    Using data provided in FlexForms in plugin CEs and custom records.

    Goals
    • I know how FlexForm data is stored in the database.
    • I can extract data from a FlexForm field.
    • I can modify the contents of a FlexForm field.

  • Database Management System (DBMS)

    Knowledge about DBMS.

    Goals
    • I know what a DBMS is and what it is used for.
    • I can name some examples.
    • I know what the term “relational” in the context of DBMS means.

  • Doctrine DBAL

    Basic knowledge about the Doctrine component for transparently accessing several DBMS in PHP.

    Goals
    • I know what Doctrine DBAL is.
    • I know the difference between Doctrine DBAL and Doctrine ORM.
    • I know the role of Doctrine DBAL in TYPO3.

  • Using the QueryBuilder

    How to write queries in TYPO3.

    Goals
    • I know how to use the QueryBuilder built into TYPO3.
    • I know how to write a secure query that can target different DBMS.
    • I know how the Core QueryBuilder differs from Doctrine DBAL’s QueryBuilder

  • Using Query Restrictions

    How to restrict database queries.

    Goals
    • I know about the restriction containers applied automatically in TYPO3.
    • I know the available restrictions and their usage.
    • I know how to change which restrictions are applied.

  • TYPO3 Debugging Utilities

    Knowledge about debugging utilities provided by TYPO3.

    Goals
    • I know the built-in mechanics to output debug messages:
      • Extbase DebuggerUtility
      • DebugUtility
      • admin panel
    • I know how to add debug output to the frontend.
    • I know how to add debug output to the backend.

  • Tracing Errors in Logs

    Knowledge about log sources and how to utilize them in order to resolve errors.

    Goals
    • I know where to look when my instance throws error messages or white pages.
    • I know which configuration options define the error output of TYPO3 and Extbase.
    • I know how to limit error output to development machines or certain IPs on live instances.

  • Logging API

    Knowledge about the logging API provided by TYPO3.

    Goals
    • I know how to compose a proper log message and of which parts it consists.
    • I know about the different log levels and their meaning.
    • I know how to get and use a logger in my code.
    • I know about log channels and how to use them in my code.

  • Debugging in PHP

    Basic knowledge about error tracing methods in PHP.

    Goals
    • I know about simple methods to print values to output (var_dump, print_r, echo, die).
    • I know how to set up and use a debugging tool like Xdebug.

  • Knowledge about Environment Error Logs

    Ability to locate logs provided by system components.

    Goals
    • I know where theerror logs of TYPO3, a web server and PHP are located.
    • I can access these logs in order to trace errors occurring in my environment.  
    • I know how to interpret error log messages in order to resolve the error.

  • PSR-7: Request/Response

    This skill covers the PSR standard for HTTP request/response objects.

    Goals
    • I have basic knowledge about the standard PSR-7.
    • I know how to deal with request and response objects in PHP.

  • Extending Existing Functionality

    Extending core and extension functionality without changing code.

    Goals
    • I know what hooks are and the two different types of hook implementations.
    • I know about PSR-14 events and how they are implemented in TYPO3.
    • I know what userFuncs in the TCA are and how to take advantage of them.
    • I can identify places where TYPO3 allows to extend built-in functionality.

  • PSR-3: Logger Interface standard

    Knowledge about the PSR-3 logging standard for PHP.

    Goals
    • I know about the interfaces defined by PSR-3.
    • I know about the standard implementations of PSR-3.
    • I know the API methods the PSR-3 LoggerInterface provides for writing log messages.
    • I can use PSR-3-based logging in my own extensions.

  • The Caching Framework

    This skill covers the Core's caching framework. It shows how to use existings caches and register custom caches and the types of cache frontends and backends. Additional topics are expiration and tagging of cache entries and flushing of caches.

    Goals

    I can:

    • use existing caches
    • register and use custom caches
    • decide which types of cache frontends and backends to use for which purpose

  • Commands

    This skill covers the creation of command-line commands for TYPO3, based on the Symfony Console component.

    Goals
    • I know how to execute existing Symfony CLI commands.
    • I can create and register new Symfony CLI commands
    • I can find my way around existing commands and can modify them.

  • Extension scanner

    This skill covers the Extension Scanner, which extension authors and project maintainers can use to detect possible problems in their extensions while upgrading them to a newer TYPO3 version.

    Goals
    • I can use the extension scanner from within the TYPO3 BE and from the command line. I know what kind of problems the scanner finds, and the limitations of the scanner.
    • I can interpret findings of the scanner and judge whether they are relevant for my project.

  • Flash Messages

    This skill covers flash messages, a mechanism used to communicate e.g. results of an action to the user.

    Goals
    • I know where the Core flash messages and notifications can be used (and where not). I know which type of flash message to use for what purpose.
    • I can create and output flash messages using PHP, HTML and JavaScript. I can output flash messages created in existing code, e.g. other extensions.

  • Mail API

    This skill covers the TYPO3 Mail API, which internally uses Symfony’s Mailer and Mime component for creating and sending emails.

    Goals
    • I can configure the Mail API for different contexts.
    • I can create new emails in my extensions and send them through the Mail API.
    • I know how to create Fluid-based emails.
    • I am familiar with the pros and cons of the different transport methods.

  • Error handling/Exception handling

    This skill provides knowledge on TYPO3-specific ways of handling errors during program execution and finding information about any errors that occurred.

    Goals
    • I can configure the error and exception handling for development and production.
    • I know when errors are handled by the error handler, and where to find any logged errors.

  • DataHandler (TCE= TYPO3 Core Engine)

    This skill handles basic knowledge of the DataHandler, a TYPO3 Core component for processing user data. It also covers how it can be leveraged in custom developed extensions.

    Goals
    • I know how the DataHandler processes data entered in forms in the Backend.
    • I know about hooks I can use for modifying data during processing.
    • I know how to use DataHandler in my own extensions (e.g. for mass-creation of records).
    • I can modify data during the processing of certain tasks (e.g. versioning).

  • Writing and using own Symfony Expressions

    This skill covers the Symfony Expression syntax used in e.g. TypoScript conditions and ways to extend that functionality with custom code.

    Goals
    • I know the Symfony component "Expression Language" and its syntax.
    • I can write and register my own ExpressionFunctionProviders.
    • I can provide custom TypoScript conditions using my own ExpressionFunctionProviders.
    • I know where expressions are used in site configurations.

  • Contexts & Aspects

    This skill introduces usage of the request context and aspects that can be used to enrich this context, e.g. with localization information.

    Goals
    • I know the difference between the ApplicationContext and the Context API.
    • I can use the Context API, know which Aspects exist, and can access information from Aspects.
    • I know how to add my own Aspects to the Context.

  • PageTitle API

    This skill covers the PageTitle API, which can be used to flexibly modify the title of the generated page, e.g. in the single view of a plugin.

    Goals
    • I know about the structure of the PageTitle API.
    • I can implement and register custom PageTitleProviders to modify the document's title.

  • Using the PageRenderer in Extensions

    This skill covers the PageRenderer for extension usage, a TYPO3 Core component that is responsible for collecting and generating information about various parts of the page and handling the final output of a page.

    Goals
    • I can use the PageRenderer to modify or extend CSS, JavaScript and other header information in frontend and backend.

  • MetaTag API

    This skill covers the MetaTag API, which can be used to manipulate the meta tags in the <head> section of the generated HTML page.

    Goals
    • I can use the MetaTag API to add, modify or remove meta tags.
    • I can implement and register my own MetaTagManagers.

  • Environment class

    This skill covers knowledge on TYPO3’s Environment class, which provides system-specific details that are independent from the system environment.

    Goals
    • I know which kind of information the Environment class in the TYPO3 Core provides.
    • I can write code that is not dependent on a specific type of operating system (Windows, Linux, etc.)

  • The System Registry API

    This skill covers the system registry API, provided by the TYPO3 Core to store instance-specific data.

    Goals
    • I can use the registry API to read and write data.
    • I can decide when the registry makes sense to use and when not.

  • PSR-15: Middlewares

    This skill covers the PHP standard on middlewares.

    Goals
    • I know what middlewares and request handlers are specified in PSR-15 and how they relate to each other.

  • Request processing with middlewares

    This skill covers the usage of PSR-15 middlewares in TYPO3 - both for frontend and backend request processing.

    Goals
    • I understand how the core leverages middlewares to modularize request processing (middleware dispatcher, chained middlewares, …).
    • I know how to find out which middlewares are configured and their order of execution.
    • I can write my own middlewares and add them to the frontend and backend request processing.
    • I can overwrite Core-provided middlewares.

  • Route Enhancers

    This skill covers route enhancers which are used to amend the URL routing provided by the TYPO3 core.

    Goals
    • I know what Route Enhancers are and about the different types that the Core provides.

  • Extending site configurations

    This skill covers custom extensions to the TYPO3 Core Site configuration module.

    Goals
    • I can add custom fields to the site configuration module.
    • I know how to read values that are stored in custom site configuration fields.

  • The USER/USER_INT TypoScript objects

    This skill covers the USER and USER_INT TypoScript objects, which are used to integrate custom code in the TYPO3 frontend rendering process.

    Goals
    • I know what the USER TypoScript object is and how it relates to plugins.
    • I know the differences between USER and USER_INT.

  • JavaScript Event API in the Backend

    This skill covers the JavaScript API for Events in the TYPO3 Backend, relevant for programming custom backend modules and extending existing modules.

    Goals
    • I know about the Event API in JavaScript
    • I can register my own event listeners
    • I know about the different event strategies and their performance implications
    • I know about the different event classes and when to use which of them

  • Providing own events

    The focus of this skill is providing custom events within the TYPO3 PSR-14 implementation.

    Goals
    • I can create events for my custom extensions and dispatch them with the Core’s EventDispatcher.
    • I know how to implement the different event use cases specified in PSR-14

  • Using existing PSR-14 events

    This skill covers the implementation and usage of events in the TYPO3 Core.

    Goals
    • I know how the TYPO3 Core defines events and attaches listeners to events.
    • I can register my own listeners for events provided by the Core, extensions and 3rd-party PHP libraries.

  • Debugging PSR-14 Event Handling

    This skill covers debugging the registration, dispatching and handling of events.

    Goals
    • I know how to retrieve a list of registered event listeners.
    • I can use the admin panel to retrieve an overview of dispatched events.

  • PSR-18: HTTP Client

    This skill covers the PSR HTTP client standard.

    Goals
    • I know about the client interface provided by PSR-18.

  • PSR-17: HTTP Message Factories

    This skill covers the PSR standard for HTTP message factories and the differences to the earlier HTTP request/response standard.

    Goals
    • I know about the various interfaces provided by PSR-17 and their different purposes
    • I know why PSR-17 was created and the differences to PSR-7

  • Notification Actions

    Notifications as flashmessages in backend can have actions assigned to interact with the editor.

    Goals
    • I know the different types of actions for notifications.
    • I know how to  define javascript actions in notification messages.

  • Backend Notifications

    The focus of this skill is to know how to utilize notifications for backend users.

    Goals
    • I know how to create notification messages in the TYPO3 backend.

  • Pagination API

    The abstraction for paginations provided by the TYPO3 Core.

    Goals
    • I know how to apply pagination to result arrays.
    • I know how to apply pagination to extbase query results
    • I know the different types of pagination the Core provides.

  • Rich Text Editor API

    Modifying CKeditor’s configuration programmatically: You can modify existing or add complete new configurations

    Goals
    • I know how to configure the Rich Text Editor in TYPO3.
    • I know how to modify YAML configuration, programatically, using events.
    • I know how to plug in a custom RTE.

  • Building Custom Dashboard Widgets

    This skill covers creating custom widgets for the TYPO3 Backend Dashboard and configuring existing widget groups.

    Goals
    • I know which abstract classes and interfaces the core provides, to build my own custom widgets.
    • I know how to register new widgets and how to assign them to one or several widget groups.
    • I can also create new widget groups.
    • I know how to create new DataProvider in order to compose new widgets based on existing widget implementations

  • Custom Route Enhancers

    This skill covers the creation of custom Route Enhancers for the TYPO3 frontend routing.

    Goals
    • I know the difference between a Route Enhancer, a Decorator and a Mapper.
    • I know how to implement a custom Route Enhancer.
    • I can use my custom Route Enhancer for to route requests to my extension

  • Database Record Translations

    This skill covers the translation configuration of database records via TCA.

    Goals
    • I can make records translatable.
    • I know how to configure translation behavior of TCA columns.
    • I am familiar with the different translation modes in relation fields (IRRE).

  • PSR-11: Symfony Dependency Management/Injection

    This skill covers different types of dependency injection in TYPO3 and the configuration of dependency injection.

    Goals
    • I can configure my extension to make use of PSR-11 dependency injection.
    • I know the different approaches to dependency injection in TYPO3.
    • I can decide which classes can be or need to be public.
    • I know how to debug problems with dependency injection.

  • AssetCollector class and ViewHelpers

    The AssetCollector class, its methods and the corresponding ViewHelpers.

    Goals
    • I can add CSS and JavaScript files to my controllers and views.
    • I know when and how to use the API, and when and how to use the f:asset.* ViewHelpers.

  • TYPO3 Version API

    The TYPO3 Version information API.

    Goals
    • I know how to retrieve the major and branch version numbers of the current TYPO3 instance.

  • Data structures in TYPO3 core

    Classes for data structures, e.g., the BitSet and Enumeration class, and their usage.

    Goals
    • I can decide in which cases to use the BitSet class, can explain the drawbacks and know how to use it properly.
    • I understand how bit sets work in general.
    • I know the use cases of the Enumeration class and the patterns to use for it.
    • I know the use case of the TypeInterface and how to use it.

  • Extension: Lowlevel

    The lowlevel extension allows examining the current TYPO3 configuration.

    Goals
    • I know which information the backend module of EXT:lowlevel provides.
    • I can examine my configuration changes with the help of the EXT:lowlevel backend module.
    • I know how to debug execution order of middlewares and event handlers with EXT:lowlevel.
    • I know how to utilize the tools that EXT:lowlevel provides for managing my development instance.

  • User-defined TCA type

    This skill covers the TCA type “user”.

    Goals
    • I know how to define a custom TCA field with custom rendering and behaviour
    • I know the difference between the `user` type and a custom `renderType`

  • TCA Types for record relations

    This skill covers TCA configuration options to define relations to other records.

    Goals
    • I know about TCA types that define record relations
    • I know how to use `renderType` for those types to change appearance and behavior

  • TCA types File and Folder

    This skill covers the TCA types "file" and "folder", used for relations from records to files and folders.

    Goals
    • I know about options to define relations from records to files/folders
    • I know how to change appearance and behaviour of those relations

  • TCA type "slug"

    This skill covers the TCA type slug to create slugs for records.

    Goals
    • I know how to define a field to integrate custom records into routing (TCA type slug)
    • I know about `generatorOptions` to influence how the slug is generated

  • TCA Types for Basic Input

    This skill groups knowledge about TCA Types that define input possibilities.

    Goals
    • I know how to define basic input fields by using TCA types
    • I know how to change appearance and behavior of the fields by using renderTypes

  • Special Input TCA Types

    This skill covers specialized text input types in TCA.

    Goals
    • I know about purpose defined special TCA types
    • I know how to configure a basic TCA type to the same purpose
    • I know how to change appearance and behavior by using 'fieldControl' technique.

  • TYPO3 Message bus

    This skill covers the TYPO3 message bus solution based on the Symfony Messenger component.

    Goals
    • I know what the message bus is and how it works.
    • I know how to create my own messages and send them over the bus.
    • I know how to create handlers for messages and register them.
    • I know why some messages should be handled asynchronously.

  • Extending the Admin Panel

    This skill covers implementing custom functionality for the Admin Panel.

    Goals
    • I know how to display information in the Admin Panel panel bar.
    • I know how to create a module for the Admin Panel.
    • I know how to include custom CSS and JavaScript files for custom modules.
    • I know how to add a custom setting to the Admin Panel and how to retrieve its value to influence my code's behaviour.

  • Admin Panel usage as a developer

    This skill handles the usage of the TYPO3 Admin Panel as an Extension Developer.

    Goals
    • I can use the Admin Panel to check dispatched events.
    • I can use the Admin Panel to check executed SQL Queries.
    • I can use the Admin Panel to check the debug log.
    • I can use the Admin Panel to check the request Info.

  • Creating Backend modules

    This skill covers the creation of custom backend modules for TYPO3.

    Goals
    • I know how to register a backend module with controller actions.
    • I know how to register a backend module with routes.
    • I know which APIs to use to get a similar look and feel as the Core's backend modules.
    • I know how to route to a backend module.
    • I know how to retrieve current request info within a module.
    • I know how to access backend module configuration.

  • Extension File and Folder Structure

    Knowing the file structure of an extension and where to place files by convention and due to technical requirements.

    Goals
    • I know how the directory structure of a TYPO3 extension looks like and the additional Extbase conventions.
    • I know the purposes of files in TYPO3 extensions (such as ext_emconf.php, ext_tables.php, and others).
    • I can create an extension that is installable via the TYPO3 Extension Manager and/or Composer.

  • Table Configuration Array (TCA)

    Configuring database tables for usage in the backend and frontend.

    Goals
    • I know about the different sections of the TCA (ctrl, columns, palettes, …).
    • I know how to configure rendering of a table in backend forms.
    • I know how the TCA controls information processing by the TYPO3 core (DataHandler).
    • I know how the TCA is compiled from different extensions and cached.
    • I can create a compliant TCA for my extensions.
    • I can extend the TCA of existing tables from the core or other extensions.

  • Database Schema Definition

    This skill handles definition of own database tables and fields for an extension for automatic management by the TYPO3 Core.

    Goals
    • I can write an ext_tables.sql file both for creating new and extending existing tables.
    • I know which fields are generated automatically based on the TCA.

  • What is SQL?

    Knowledge about how to access and manipulate data in DBMS.

    Goals
    • I know where to find information about SQL.
    • I know how to issue queries against my local setup.

  • Creating Scheduler Tasks and Commands

    How to build Scheduler tasks and commands for automating recurring tasks.

    Goals
    • I know how to create a new Scheduler task.
    • I know how to create a new command.
    • I know about the context Scheduler tasks are executed in.
    • I know about the context commands are executed in.
    • I know that commands can be executed as scheduler tasks.
    • I know the differences between scheduler tasks and commands.

  • Composer for TYPO3 Extensions

    This skill introduces usage of Composer for extensions and their integration into TYPO3 projects.

    Goals
    • I know which fields to use in the composer.json of my extension, what they mean and how they work, so that I can create working, readable and helpful composer.json files.
    • I can use 3rd-party extensions and my own extensions in my site project via Composer.
    • I also know the benefits and drawbacks of using Composer and can advise my coworkers and clients when to use which approach.
    • In addition, I can build composer.json and ext_emconf.php files in such a way that their data is synchronized correctly.
    • I know how to provide and access public assets in a composer installation.
    • Also, I know how to update the autoloader data for non-Composer installations.

  • JavaScript handling in the Backend

    This skill covers the TYPO3-specific parts of RequireJS: how this library is used in TYPO3 and how developers can leverage the TYPO3 Core API to use their own JavaScript code in the TYPO3 Backend.

    Goals
    • I know how to write JS code that is compatible with the TYPO3 backend.
    • I know how to load my JS code via the PageRenderer.
    • I know how to register custom JS namespaces in my extension.
    • I can include and use third-party JS modules in my extension’s JS code.
    • I know how to migrate legacy RequireJS modules to the ES6-based.

  • AJAX handling in the TYPO3 Backend

    Basic knowledge about how AJAX actions are handled in the TYPO3 Backend and how custom code can be added to be called via AJAX.

    Goals
    • I can register routes for backend AJAX calls.
    • I know how to process incoming AJAX requests in PHP.
    • I can execute AJAX requests in JavaScript.
       

  • Implementing upgrade wizards

    This skill covers the implementation of upgrade wizards, which can be used by integrators to update existing extension data and configuration after upgrading the extension.

    Goals
    • I can implement an update wizard and know when to use it.

  • PHP autoloading standards

    The different PHP autoloading standards (PSR-4, class maps), how they map PHP classes to files and folders, and how the PSR-4 autoloading is configured.

    Goals
    • I know where to place the class file for a certain class in a certain namespace when using PSR-4 autoloading.
    • I can set up a proper PSR-4 autoloading configuration.
    • I know how to debug and solve problems related to autoloading.

  • Making Extensions localizable

    How to make extensions translatable and localizable.

    Goals
    • I know conventions for language file names and file paths in TYPO3. 
    • I know the basics of the translation concept of TYPO3. 
    • I can translate labels in Fluid (f:translate ViewHelper). 
    • I can provide translatable TCA and Flexform labels.

  • Coding Standards in TYPO3

    Knowing how to write code conforming to the coding standards used by the TYPO3 project.

    Goals
    • I am familiar with the PSR standard and the usage in TYPO3.
    • I know the TYPO3 namespace conventions.
    • I know the official TYPO3 coding guidelines for PHP, JavaScript, etc.

  • Docblocks in PHP

    The syntax and general purpose of documentation blocks, and the most often used annotations.

    Goals
    • I know how PHPDoc blocks look and I know the general purpose and limitations.
    • I can write valid annotations.

  • Performance analysis for custom code

    This skill covers the process of analysing performance of a TYPO3 system.

    Goals
    • I know common performance metrics
    • I know how to analyze the performance of a TYPO3 site
    • I know how to analyze the performance of my custom plugins
    • I know where to get a first overview of the rendering performance

  • PHP Code Style Tools

    This skill covers tools for automatic code formatting in PHP.

    Goals
    • I know about standard tools for code formatting in PHP.
    • I know how to use the tools.
    • I know how to integrate the tools into workflows like CI Pipelines.

  • Static code analysis

    Developing and maintaining large code bases can be cumbersome. Tools providing static code analysis can help.

    Goals
    • I know what static code analysis is and why it is useful.
    • I know how to integrate static analysis tools into workflows.
    • I know some popular and widely used static analysis tools for PHP

  • Implementing MVC in TYPO3

    Introducing the concept of MVC in Extbase: base classes for models, controllers, repositories; the concept of services and utilities and when to use them.

    Goals
    • I know which kinds of models exist in Extbase.
    • I know how a repository for a model is implemented.
    • I know how plugins relate to controllers and actions.
    • I know how TYPO3/Extbase determines a template for a controller action.
    • I can create a new plugin with one or multiple controllers.
    • I can define templates for my controller actions.
    • I can create a model and the related repository.

  • Implementing ViewHelpers

    Provides the foundations for using custom PHP code in a Fluid-based view.

    Goals
    • I know which base classes for ViewHelpers exist.
    • I know which functionality should be placed in a ViewHelper and what is better suited for a controller, service or utility.
    • I can create my own ViewHelpers and use them in a template.
    • I can register custom ViewHelper arguments.
    • I can implement a custom conditional ViewHelper.

  • Extbase Request/Response

    How requests are handled by Extbase.

    Goals
    • I know how an Extbase request relates to the TYPO3 page rendering process.
    • I know how Extbase namespaces its arguments.
    • I know the difference between forwards and redirects.
    • I can extract arguments from the request data.
    • I can add custom data to a response in my controller actions.

  • Extbase View

    Explaining the view part of MVC in Extbase.

    Goals
    • I know how data is passed to the view.
    • I know how a view is configured in a controller.
    • I know how different types of views can be used.
    • I can pass variables to my template.

  • Extending Base Models

    This skill covers the use cases and different ways to extend the built-in models of Extbase.

    Goals
    • I know which models are shipped with Extbase by default.
    • I know when to use which default model as a base for own models.
    • I know how to map database fields to properties using PHP configuration (fieldName).

  • Extbase Persistence

    How Extbase interacts with the permanent storage.

    Goals
    • I know how Extbase works when it stores and retrieves persistent data.
    • I know the lifecycle of an object.

  • Extbase PersistenceManager

    The built-in PersistenceManager.

    Goals
    • I am familiar with the PersistenceManager class.
    • I know when to use the class to manually trigger I/O operations.
    • I know at what point the PersistenceManager is triggered to automatically persist data.

  • Standard Extbase Repository

    Knowing the default Repository class shipped with Extbase.

    Goals
    • I know which default query methods are shipped.
    • I know which restrictions apply to queries by default.
    • I know how to create a repository based on the default Repository class

  • Customizing Extbase Repositories

    How to implement custom persistence functionality in Extbase.

    Goals
    • I know how to apply customized query settings to all repository queries.
    • I know how to manipulate query settings for a specific method.
    • I know the difference between Extbase and Doctrine queries.
    • I can create custom queries using the Extbase mechanisms.

  • Validation in Extbase

    What concepts exist to validate controller action input parameters.

    Goals
    • I know about annotations to validate model properties.
    • I know what input parameter validation is automatically applied to controller actions.
    • I know about annotated validations for controller actions.

  • Implementing Custom Validators

    How to provide custom data validation in Extbase.

    Goals
    • I know which classes I can use as a base for my validator.
    • I know where to put a custom validator class by convention and how to register the class.
    • I know in which location a custom validator class should be stored by convention and how to register the class.
    • I know how to use the validator in a controller action.

  • Error Actions

    How to handle validation errors.

    Goals
    • I know about the built-in error action, how it works and when it is used.
    • I know how to provide a custom error action by overriding the default.

  • Controller

    This skill covers controllers, the "C" in the MVC pattern.

    Goals

    I know which role controllers play in the pattern.


  • Extbase Annotations

    This skill is about PHPDoc annotations particular to Extbase.

    Goals
    • I can use the correct Extbase annotations in my models and controllers.
    • I know which annotation I should use when several possible options are available.

  • Registering Backend Modules

    This skill covers the registration of a backend module to make it available to users.

    Goals
    • I can register backend modules based on Extbase.
    • I can register backend modules without Extbase.

  • Registering Frontend Plugins

    This skill covers the registration of a frontend plugin to make it available to users.

    Goals
    • I know how to register a plugin with and without Extbase.
    • I know how to register a plugin/controller as a content element.
    • I know how to declare actions as uncached in Extbase.
    • I know how to register a cached or uncached plugin without Extbase.

  • EXTBASEPLUGIN TypoScript Object

    This skill covers the integration of Extbase plugins into rendering via TypoScript.

    Goals
    • I can call an Extbase plugin via an EXTBASEPLUGIN TypoScript cObject.
    • I know how caching works with EXTBASEPLUGIN.

  • Handling User Input

    Knowledge about possible ways to retrieve and process user input.

    Goals
    • I know how to access the arguments and values of a URL.
    • I know how to access data passed into the system from forms.
    • I know how to retrieve data from third-party systems.
    • I know the typical security risks when user input is accessed/processed.

  • User Input in DB Queries

    Knowledge about securely processing user input for database queries.

    Goals
    • I know what an SQL injection is.
    • I know how to sanitize user input to prevent SQL injections.
    • I know what other measures to take against SQL injections.

  • User Input in Views

    Knowledge about securely outputting values gained through user input.

    Goals
    • I know what cross-site scripting (XSS) is.
    • I know how to prevent user input from triggering XSS.

  • User Input in PHP Code

    Knowledge about securely processing user input in PHP code.

    Goals
    • I know about vulnerabilities path traversal, arbitrary code execution and information disclosure.
    • I can apply mitigations to prevent these vulnerabilities.

  • Web Vulnerability Types

    Knowledge about possible vulnerabilities in web development.

    Goals
    • I know what cross-site scripting (XSS) is.
    • I know what arbitrary code execution is.
    • I know what an SQL injection is.
    • I know how I can prevent these vulnerabilities in my code.

  • Prepared Statements

    This skill covers the concept of Prepared Statements in relational databases.

    Goals
    • I know what prepared statements are and what their purpose is
    • I know how they improve security and against which attack vectors they  are useful.

  • Content Security Policy in Extensions

    This skill covers the usage and configuration of CSP in TYPO3 Extension.

    Goals
    • I know how to configure CSP via PHP
    • I know how to integrate assets in a CSP conform way
    • I know to make use of 3rd Party assets in a CSP conform way

  • Composer

    Composer basics and its usage for PHP projects.

    Goals

    I know

    • what Composer is
    • the purpose and the structure of file composer.json
    • what composer.lock is and which purpose it serves
    • the difference between the install and the update command

    I can

    • create a new Composer project
    • specify requirements for my project
    • install packages using Composer
    • update packages
    • remove packages

  • Git basics

    Basics and most important commands for working with the version-control system Git.

    Goals

    I know

    • what a VCS is
    • what a branch is
    • what a tag is
    • what a repository is
    • what a merge is

    I can

    • initialize a Git repository
    • execute commands "commit", "push" and "pull"
    • create a branch and work on it
    • assign a tag to a certain development state
    • merge code

Track your skills and learning progress

See skillset at SkillDisplay

Download as PDF

Download Syllabus