TYPO3 CMS Certified Developer (TCCD)

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

• I have a basic understanding of what MVC is.

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

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

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

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

Understanding the concept of DDD.

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

Ability to develop and execute PHP scripts.

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

This skill covers the model in the MVC context.

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

What is a view in MVC context.

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

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

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

Knowledge about dependency injection in general.

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

TYPO3 provides some concrete classes following the Builder design pattern.

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

Understanding the “Builder” Design Pattern.

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

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

• 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

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

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

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

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

Getting to know what a ViewHelper is.

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

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

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

Including comments in Fluid templates.

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

Creating if/else statements within Fluid templates.

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

Iterating through a list with the for ViewHelper.

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

Using third party ViewHelpers in your Fluid templates.

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

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

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

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

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

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

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

Using Fluid Format ViewHelpers.

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

Using the Fluid ViewHelper f:image().

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

The JSON format and its usages in web development.

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

The built-in JSON View in Extbase.

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

The Fluid-based HTML view of Extbase.

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

Utilising output to access Fluid variables.

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

The TYPO3 CMS form ViewHelper for Fluid.

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

This skill covers the creation of data processors for TYPO3.

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

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.

• 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

Know about transparent inclusion of external file sources into TYPO3.

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

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

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

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

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

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

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

Knowledge about DBMS.

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

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

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

How to write queries in TYPO3.

• 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

How to restrict database queries.

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

Knowledge about debugging utilities provided by TYPO3.

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

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

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

Knowledge about the logging API provided by TYPO3.

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

Basic knowledge about error tracing methods in PHP.

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

Ability to locate logs provided by system components.

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

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

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

Extending core and extension functionality without changing code.

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

Knowledge about the PSR-3 logging standard for PHP.

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

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.

I can:

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

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

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

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.

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

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

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

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

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

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

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

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.

• 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).

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

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

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

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

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.

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

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.

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

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

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

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

• 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.)

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

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

This skill covers the PHP standard on middlewares.

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

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

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

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

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

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

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

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

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

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

• 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

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

• 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

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

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

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

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

This skill covers the PSR HTTP client standard.

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

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

• 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

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

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

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

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

The abstraction for paginations provided by the TYPO3 Core.

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

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

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

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

• 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

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

• 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

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

• 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).

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

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

The AssetCollector class, its methods and the corresponding ViewHelpers.

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

The TYPO3 Version information API.

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

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

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

The lowlevel extension allows examining the current TYPO3 configuration.

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

This skill covers the TCA type “user”.

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

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

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

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

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

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

• 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

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

• 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

This skill covers specialized text input types in TCA.

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

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

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

This skill covers implementing custom functionality for the Admin Panel.

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

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

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

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

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

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

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

Configuring database tables for usage in the backend and frontend.

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

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

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

Knowledge about how to access and manipulate data in DBMS.

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

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

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

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

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

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.

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

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

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

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.

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

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.

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

How to make extensions translatable and localizable.

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

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

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

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

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

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

• 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

This skill covers tools for automatic code formatting in PHP.

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

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

• 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

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

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

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

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

How requests are handled by Extbase.

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

Explaining the view part of MVC in Extbase.

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

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

• 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).

How Extbase interacts with the permanent storage.

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

The built-in PersistenceManager.

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

Knowing the default Repository class shipped with Extbase.

• 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

How to implement custom persistence functionality in Extbase.

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

What concepts exist to validate controller action input parameters.

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

How to provide custom data validation in Extbase.

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

How to handle validation errors.

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

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

I know which role controllers play in the pattern.

This skill is about PHPDoc annotations particular to Extbase.

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

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

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

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

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

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

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

Knowledge about possible ways to retrieve and process user input.

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

Knowledge about securely processing user input for database queries.

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

Knowledge about securely outputting values gained through user input.

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

Knowledge about securely processing user input in PHP code.

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

Knowledge about possible vulnerabilities in web development.

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

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

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

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

• 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 basics and its usage for PHP projects.

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

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

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