TYPO3 CMS Certified Developer (TCCD)

This skill covers knowledge about the file structure of an extension and where to place files by convention and due to technical requirements.

• I know what the directory structure of a TYPO3 extension looks like.
• I know about additional Extbase conventions for file locations.
• I know the purposes of files in TYPO3 extensions (such as composer.json, ext_and others).

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

• I know the TYPO3 namespace conventions.
• I know the official TYPO3 coding guidelines for PHP, JavaScript, and other languages.

This skill covers 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.

This skill introduces the concept of MVC in Extbase: base classes for models, controllers, repositories.

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

This skill covers knowledge about 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 know what XClassing is and when and how to use it.
• I can identify places where TYPO3 allows to extend built-in functionality.

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 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 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 contexts.
• I know when errors are handled by the error handler, and where to find any logged errors.

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 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 knowledge of 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.

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 classes for data structures, e.g., the BitSet and Map 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 case of the TypeInterface and how to use it.
• I know about the Map class and how it compares to PHP’s built-in map types.

This skill covers Versioning & Workspaces in TYPO3 which allow to manage content changes and staging through version control and isolated workspaces. It allows for tracking revisions, previewing changes before publication, and coordinating collaborative work by separating development from live content.

• I know the concepts of versioning and workspaces in TYPO3 and their roles in content management.
• I know how custom tables are enabled for versioning and usage in workspaces.

This skill covers the TYPO3 Scheduler extension, which enables the scheduling and automation of tasks within TYPO3, such as executing background jobs, sending emails, or running custom scripts at specified intervals. This tool provides a flexible interface for managing and configuring scheduled tasks to enhance site functionality and automation.

• I know the features and capabilities of the TYPO3 Scheduler extension.
• I know how to create schedulable tasks from existing CLI commands.

This skill covers the purpose of the TYPO3 Ecosystem & Brand. It encompasses the community, tools, and resources that support the TYPO3 CMS, as well as the values and identity of the TYPO3 brand. This ecosystem includes a wide range of extensions, documentation, events, and a global community that contribute to the development and promotion of TYPO3.

• I know the components of the TYPO3 ecosystem, including the community, extensions, and resources.
• I know about the TYPO3 brand, its values, and its role in shaping the CMS's identity.
• I know how to engage with and contribute to the TYPO3 community and ecosystem.

This skill covers TYPO3 Contribution. This involves participating in the development and enhancement of the TYPO3 CMS through various means such as code contributions, documentation, bug reports, and community support. Engaging with TYPO3 contributions helps improve the platform and supports the global TYPO3 community

• I know the different ways to contribute to TYPO3, including code, documentation, and community support.
• I know how to get involved with the TYPO3 development process and contribute effectively.
• I know the benefits of contributing to TYPO3 and how it supports both personal growth and the TYPO3 ecosystem.

TYPO3 organises its page tree in one or multiple sites. This skill covers the configuration of these sites in the system.

• Understand how TYPO3 manages the configuration for sites

This skill covers the usage of the Single Table Inheritance technique in TYPO3. It is used in TYPO3 to manage multiple object types within a single database table. This approach allows different classes to share the same table while maintaining distinct behaviors, simplifying database structure and improving performance in TYPO3 extensions.

• I know how Single Table Inheritance works in TYPO3 and its benefits.
• Learn about examples where STI is used in the TYPO3 Core.
• I know how to configure and implement Single Table Inheritance for managing different object types in a unified table.
• I know the advantages and considerations of using this inheritance model in TYPO3 projects.

This skill covers Frontend Plugins in TYPO3 which are a content type that adds custom functionalities to the frontend of a TYPO3 website. These plugins allow for the integration of custom features and interactive components, enhancing the user experience and extending the site's capabilities.

• I understand the purpose and types of frontend plugins available in TYPO3.
• I know how to create and configure frontend plugins to add functionalities to a site.

The Fluid Templating Engine is a powerful and flexible template engine used in TYPO3 for rendering dynamic content in a clean and maintainable way. It allows developers to create custom templates using a combination of HTML and Fluid-specific syntax, enabling the separation of content and presentation layers.

• Understand the basics of the Fluid Templating Engine in TYPO3.
• Learn to create and customize templates using Fluid.
• Recognize how Fluid integrates with TYPO3 to manage content presentation.

This skill covers Feature Toggles which allows developers and integrators to enable or disable specific functionalities or features dynamically without altering the codebase. This technique is used in TYPO3 mainly to hide breaking changes for existing installations migrating from older versions.

• I know the concept and purpose of feature toggles in TYPO3.
• I know how to check the state of a feature toggle in your own extensions.

This skill covers session management in TYPO3. Session Management involves handling user sessions to maintain state and manage user interactions across multiple page requests. This includes creating, storing, and retrieving session data to provide a consistent user experience and manage user-specific settings or actions.

• I know how session management is implemented in TYPO3
• I know about the lifecycle of sessions in TYPO3

This skill covers the Upgrade Wizards in TYPO3 which assist with the process of upgrading TYPO3 installations and extensions by automating data migrations needed to ensure compatibility with newer versions.

• I know the role and functionality of Upgrade Wizards in TYPO3.
• I know how to use Upgrade Wizards to support upgrades of TYPO3 extensions.
• I know how to iImplement and verify the changes made by Upgrade Wizards to ensure a smooth transition to newer versions.

This skill covers TYPO3's persistence engine, which handles data management and storage within the system. This includes understanding how TYPO3 structures and maintains data integrity, as well as the mechanisms that support consistent data handling across the Backend and Frontend.

• I know about the Core’s persistence engine for the Backend and the Extbase Persistence Layer
• I know the key concepts like the Table Configuration Array (TCA), the Schema manager and the Reference Index

This skill covers the different ways how objects can be created in TYPO3, and the infrastructure TYPO3 provides for this.

• I know the basics of Dependency Injection in TYPO3.
• I know when to create objects myself and when to retrieve an instance created by the Framework.

This skill covers TYPO3 Backend Modules. That is a functional component that extends the capabilities of the TYPO3 backend, allowing users to manage specific tasks or access additional tools within the content management system. These modules can be custom-built or come as part of extensions, providing enhanced functionality tailored to the needs of the website.

• I understand the purpose and structure of Backend Modules in TYPO3.
• I can navigate and utilize a Backend Module within the TYPO3 Backend.
• I understand the role of Backend Modules in extending TYPO3’s functionality.

This skill covers the cHash (cache hash) in TYPO3 which is used to prevent cache flooding and to ensure that cached content is correctly identified and served based on query parameters and URL changes. This mechanism helps in generating unique cache entries for different content variations, improving cache accuracy and preventing stale content from being served.

• I know the purpose and functionality of cHash in TYPO3.
• I know how cHash helps manage cache entries based on URL parameters and variations.
• I know how to implement and troubleshoot cHash to ensure accurate and efficient content caching.

Frontend Routing in TYPO3 manages the mapping of URLs to specific pages, plugins and content within a TYPO3 site. It defines how URLs are structured and resolved, ensuring that users and search engines can access the correct content efficiently.

• Understand how frontend routing works in TYPO3 and its role in URL management.
• Learn to configure and customize URL routes for custom plugins.

This skill covers the TYPO3 Request Lifecycle. Which is the process a request undergoes from the moment it is received by the server until a response is delivered to the client. This life cycle includes stages such as routing, controller action execution, and rendering, ensuring that TYPO3 handles each request consistently and efficiently.

• I know how TYPO3 processes a request from start to finish, including routing, controller actions, and rendering.
• I know when and how to extend or customize the request lifecycle in TYPO3 projects.

This skill covers validation in TYPO3 which involves ensuring that user input and data conform to defined rules and constraints to maintain data integrity and quality. This process includes configuring validation rules for forms and data models, checking for errors, and providing feedback to users to ensure correct and secure data handling.

• I know the principles and methods of validation in TYPO3.
• I know about the different places where validation is used in TYPO3.

Logging in TYPO3 refers to the system’s ability to track and record various activities and events within the CMS, such as user actions, errors, and system processes. Effective logging helps administrators monitor system health, troubleshoot issues, and maintain a secure and well-functioning TYPO3 installation.

• Understand how logging works in TYPO3.
• Identify where to access and review logs.
• Utilize logging information for troubleshooting and system maintenance.
• I know how I can reconfigure logging output
• I know how to configure specific channels to group logging messages

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.
• I know the most important standards used in the TYPO3 world.

This skill covers basics of the JSON format.

• I can recognize data encoded in JSON.

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

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

This skill covers knowledge of the syntax and general purpose of documentation blocks, and the most often used annotations.

• I know how PHP DocBlocks look and I know the general purpose and limitations.
• I can write valid annotations.
• I know when I can omit parts or whole DocBlocks

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

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.

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

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

This skill covers the standard XML format XLIFF (XML Localization Interchange File Format) which is used for the exchange of localization data between different software tools. It facilitates the translation and management of text within applications by providing a structured format for source and target language content.

• I know the structure and purpose of XLIFF files.
• I know how to use XLIFF for managing translation and localization data.

This skill covers the lightweight markup language reStructuredText (reST). Which is used for formatting text.

• I know the basic syntax and features of reStructuredText
• I know how to format and structure documents using reST

This skill covers the lightweight markup language Markdown. Which is designed for formatting text in a simple and readable way

• I know the basic syntax and features of Markdown
• I know how to format text and different elements like lists or links using Markdown
• I know how to add images in Markdown
• I know about the different flavors of Markdown

This skill covers the knowledge of CVE (Common Vulnerabilities and Exposures). CVE  provides a standardized identifier for publicly known cybersecurity vulnerabilities and exposures. This system helps organizations and users track and manage security issues by offering a unique reference for each vulnerability.

• I know what CVE is and how it helps in identifying and managing vulnerabilities.
• I know how to use CVE identifiers to track and address security issues.
• I know how to implement practices to stay informed about CVE updates relevant to your systems.

This skill covers the principles of SQL Data Management, including the processes of querying, updating, and organizing data within a relational database using SQL commands.

• I know how to perform data retrieval and manipulation using SQL commands
• I know how to manage and update records effectively in a relational database
• I know how to implement practices to ensure data integrity and consistency during operations

This skill covers designing and maintaining the schema of a relational database with SQL Structure Management including the creation, modification, and optimization of tables, indexes, and relationships. It ensures that the database structure supports efficient data storage and retrieval while adhering to integrity constraints and normalization principles.

• I know the principles of database schema design and structure management
• I know how to create and modify database tables, indexes, and relationships using SQL
• I know how to implement best practices for database normalization and optimization

This skill covers the methods for requesting and delivering resources by HTTP (Hypertext Transfer Protocol), such as web pages and files, and includes status codes to indicate the result of these requests.

• I know the basic functions and structure of HTTP
• I know the different HTTP methods (e.g., GET, POST, PUT, DELETE) and their purposes
• I know the HTTP status codes and their meanings

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.

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

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.

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

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.

This skill 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 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

This skill covers knowledge about the logging API provided by TYPO3.

• 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.
• I know how to compose a proper log message and which parts it consists of.

This skill covers building Scheduler tasks and commands for automating recurring tasks.

Please note that using Symfony Commands is the recommended way to run code via EXT:scheduler.

• I know the differences between scheduler tasks and commands.
• 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 configured to be available as scheduler tasks.
• I know how to create a new Scheduler task without a command.
• I know how to create a new command and how to make it executable via the Scheduler.

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

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

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 covers the TYPO3-specific parts of ES6: how to load modules 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.

This skill covers knowledge about how AJAX actions are handled in the TYPO3 Backend and how custom code can be made available for AJAX calls.

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

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 usage of PSR-15 middlewares in TYPO3 - both for frontend and backend request processing.

• I know 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 know how to write my own middlewares and add them to the frontend and backend request processing.
• I know how to overwrite Core-provided middlewares.

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 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 know how to 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.
• I know how to dispatch custom events within my extensions.
• I know the best practices for defining events.

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 TYPO3 Core, extensions and 3rd-party PHP libraries.

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.

This skill covers 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.

This skill covers the knowledge of modifying CKeditor’s configuration programmatically: 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, programmatically, 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 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 more widget groups.
• I can also create new widget groups.
• I know how to use a custom data provider in order to create a new widget 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 to route requests to my extension.

This skill covers the AssetCollector class and the corresponding ViewHelpers, which are used to register and render CSS and JS assets.

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

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 backend module.
• I know how to debug the execution order of middlewares and event listeners.
• I know how to utilize the provided tools for managing my development instance.

This skill covers managing and optimizing the storage of frequently accessed data to improve performance. This includes configuring different types of caches, such as page and object caches, and using the CacheManager to clear or manage cache entries effectively.

• Understand the different types of caches available in TYPO3 and their purposes
• Configure and use caches to enhance performance and efficiency
• Manage and clear cache entries using CacheManager

The Exception and Error Handlers in TYPO3 manage and respond to errors and exceptions within an installation. It includes configuring custom error pages, logging errors, and implementing strategies for handling various types of exceptions to ensure a smooth user experience and reliable system operation.

• Understand the functionality of TYPO3's Exception and Error Handlers
• Configure custom error pages and manage error logging
• Implement strategies for handling different types of errors and exceptions in TYPO3

The Sites PHP API allows accessing the configuration of a specific site and resolving sites from within PHP. It allows for accessing site-specific settings such as languages, error handling, and base URLs through a centralized interface.

• Understand the functionality and use cases of the Sites API in TYPO3
• Access site-specific configurations, such as language options and error handling, using the Sites API

This skill covers Session Handling in TYPO3, both for backend and frontend. This includes knowledge about the session lifecycle and adding, reading, and removing session data.

• Understand the basics of session handling in TYPO3
• Manage session data for user interactions

Authentication involves verifying the identity of users to grant access to protected areas and functionalities. This process includes configuring authentication mechanisms, handling user login and logout, and managing user credentials securely. This skill covers understanding how these mechanisms work in TYPO3.

• Understand the principles of authentication in TYPO3.
• Configure and manage authentication mechanisms for user access control.

This skill covers creating and configuring custom modules for the TYPO3 backend. This process includes defining module functionality, setting up module access permissions, and integrating the module into the TYPO3 backend interface.

• I know the process of registering and configuring custom backend modules in TYPO3.
• I know how to set up module functionality and access permissions.
• I know how to integrate custom modules into the TYPO3 backend for enhanced administrative capabilities.

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.

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

This skill covers knowledge about 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.
• I know the relationship of Extbase request/response and their TYPO3 Core counterparts.

This skill explains 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 knowledge about 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.

This skill covers knowledge of 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.

This skill covers knowdlege about 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.

This skill covers 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

This skill covers implementing custom persistence functionality in Extbase.

• I can create custom queries using the Extbase mechanisms.
• I know about naming conventions for query methods.
• 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.

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.

This skill covers knowledge of 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.

This skill covers 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 is about PHPDoc annotations and PHP attributes 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 know how to register backend modules based on Extbase.
• I know how to 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.

Single Table Inheritance (STI) in Extbase is a technique used to manage inheritance within a single database table, enabling multiple classes to share the same table while distinguishing between them using a discriminator column. This method simplifies database design and improves performance by reducing the number of tables and joins needed for inheritance hierarchies in TYPO3 extensions.

• Understand the concept of Single Table Inheritance (STI) and its implementation in Extbase
• Be able to configure Extbase models to use STI and define a discriminator column
• Recognize the advantages and potential pitfalls of using STI in TYPO3 projects

Error and Exception Handling in Extbase involves managing and responding to errors and exceptions that occur within TYPO3 extensions. This includes configuring custom error pages, logging exceptions, and implementing strategies to handle exceptions gracefully within Extbase controllers
and services.

• Understand how to handle errors and exceptions in Extbase.
• Configure custom error handling and exception logging.
• Implement strategies for graceful exception management in Extbase extensions.

This skill covers foundations of how the MVC pattern was implemented within Extbase.

• Understand how Controllers work in Extbase
• Know the views provided by Extbase
• Understand how a view is configured in a controller

This skill covers basic knowledge about the Doctrine Database Abstraction Layer (DBAL) 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.

This skill covers knowledge about notifications as flashmessages in the backend and that they 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.

Symfony Routing is a component used in TYPO3 to map HTTP requests to specific controllers and
actions. It allows for defining routes using various methods, including annotations and YAML, and
supports complex routing requirements such as parameter constraints and localization.

• Understand how to define and configure routes in a Symfony application
• Be able to use different methods for route definition, including annotations, YAML, and PHP
• Implement route parameters, constraints, and localization in Symfony routes

Symfony Finder is a component that provides a fluent interface for locating files and directories based on various criteria, such as name, size, and modification date. It simplifies file system operations in Symfony applications, making it easier to handle file searches and manipulations.

• Understand the functionality and use cases of the Symfony Finder component
• Be able to perform file and directory searches using different criteria and filters
• Implement file system operations in Symfony applications using the Finder component

The Symfony Console component

• What does Symfony Console provide
• How can Symfony Console be extended

Symfony Mailer is a component for sending emails from applications. It supports various transport
methods, including SMTP, Sendmail, and third-party services, and provides features such as email
templating, attachments, and logging.

• Understand the basics of configuring and using Symfony Mailer
• Be able to send emails using different transport methods and services
• Implement advanced email features such as templating, attachments, and logging in TYPO3 applications

Symfony Dependency Injection is a core design pattern used in Symfony applications to manage the creation and injection of service dependencies. This component promotes the decoupling of application components, making the code more modular, testable, and maintainable.

• Understand the principles of dependency injection and its benefits
• Be able to configure and manage services in Symfony using the Dependency Injection component
• Implement dependency injection in controllers and other services, leveraging autowiring and service configuration

The Symfony Expression Language Component

• What is Symfony Expression Language
• How to extend Symfony Expression Language

This skill covers 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 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.

Authentication and Authorization are key security processes that control access to a system. Authentication verifies a user's identity, while authorization determines the permissions and access levels that the authenticated user has within an environment. Implementing these processes effectively ensures that only authorized users can access specific features and data.

• Understand the difference between authentication and authorization.

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.

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

This skill covers 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 Xdebug.
• I know how break points in Xdebug work.

This skill covers the ability to locate logs provided by system components and TYPO3.

• I know where the error 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 and stack traces in order to resolve the error.

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.
• I know ways to scan extensions independently of the current TYPO3 version.

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.

The PHP Package used for generating and rendering documentation.

• What is phpDocumentator
• How to use phpDocumentor

This skill covers concepts related to automated code migrations. They help with updating existing program code for usage with newer TYPO3 versions and with applying best practices.

• I know existing frameworks for automated code migrations, like (TYPO3) Rector and Fractor.
• I know about the advantages of applying code migrations during upgrades and regular development work.

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

View Models serve as intermediaries between the controller and the view, encapsulating the data and logic required for rendering templates. This approach promotes a cleaner separation of concerns, making it easier to manage complex data structures and maintain reusable, organized code.

• Understand the role of View Models.
• Learn how to create and use View Models to pass data to templates.
• Recognize the benefits of using View Models for clean and maintainable code.

The term SOLID Principles refers to a set of design principles aimed at creating maintainable, scalable, and robust software. By adhering to these principles—Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion—developers can write cleaner, more modular code, making their software easier to manage and extend.

• Understand the five SOLID principles and their importance in software development.
• Recognize the benefits of SOLID principles in creating scalable and adaptable software projects.

Software tests involve systematically checking and validating the functionality, performance, and reliability of your code to ensure it behaves as expected. Implementing tests, such as unit tests or functional tests, helps catch bugs early, improve code quality, and maintain stable and reliable software.

• Understand the importance of software testing in software development.
• Learn about different test types and their strengths and weaknesses.

Single Table Inheritance (STI) is a database design pattern where multiple related entities are stored in a single database table, distinguished by a type or discriminator column. This approach simplifies data management by reducing the number of tables and leveraging flexible data handling capabilities.

• Understand the concept of Single Table Inheritance.
• Learn how to implement and manage STI in database structure.
• Recognize the advantages and potential trade-offs of using Single Table Inheritance.

Routing refers to the process of mapping URLs to specific controllers and actions within the system, enabling the creation of clean, user-friendly URLs. Effective routing ensures that requests can efficiently be directed to the appropriate content or functionality, improving site navigation, user experience and SEO performance.

• Understand the concept and purpose of routing.
• Learn how to configure and manage routes to control URL structures.
• Recognize the impact of routing on site performance, SEO, and user experience.

Recurring Code Tasks refer to automated processes or scripts that run at regular intervals to perform routine maintenance, updates, or other repetitive tasks. These tasks help ensure that your TYPO3 site remains efficient, up-to-date, and properly maintained without manual intervention.

• Understand the purpose and benefits of automating recurring code tasks.
• Learn how to set up and manage recurring tasks using TYPO3’s scheduling tools.
• Recognize best practices for ensuring the reliability and efficiency of automated tasks.

Migration between versions involves upgrading from one major version to another, ensuring that all features, and configurations remain functional. This process requires careful planning and execution to maintain system stability and take advantage of new features and improvements

• Understand the process and importance of migrating between versions.
• Learn the steps involved in preparing, executing, and validating a migration.
• Recognize potential challenges and best practices for a successful migration.

The extensibility through extensions in TYPO3 allows developers to enhance the core functionality of TYPO3, adding new features or improving performance. These extensions can be integrated into TYPO3 to support additional functionalities, optimize processes, or interact with external services, providing a more robust and versatile system.

• Understand the role of PHP extensions in extending TYPO3’s capabilities.
• Learn how to identify, install, and configure PHP extensions for TYPO3.
• Recognize the impact of PHP extensions on performance and functionality.

Asynchronous Task Execution allows tasks to be processed in the background without blocking the main application flow. This approach is ideal for handling time-consuming or resource-intensive operations, ensuring that the system remains responsive while tasks are executed efficiently in parallel.

• Understand the concept of asynchronous task execution.
• Learn about constraints to consider when moving a task to asynchronous execution.
• Recognize the benefits of using asynchronous task execution for enhanced performance, scalability, and system decoupling.

Localization refers to the process of adapting content, interfaces, and functionality to different languages and regions. This ensures that software can cater to diverse audiences by providing accurate translations and regional settings, enhancing user experience and accessibility across various locales.

• Understand the concept and importance of localization.
• Learn how localization differs from a simple translation of texts.
• Recognize best practices for effective and consistent localization.

Internationalization is the process of preparing a website and its content to support multiple languages and regional formats. This involves designing for various languages, date formats, currencies, and cultural differences, ensuring that ayour TYPO3 website or software can effectively reach and engage a global audience.

• Understand the concept and importance of internationalization.
• Learn how to implement internationalization features, such as language handling and localization settings.
• Recognize best practices for developing a TYPO3 site that can easily adapt to different regions and languages.

Meta Programming involves creating code that can manipulate or generate other code, providing powerful ways to automate tasks and create more adaptable systems.

• Understand the principles and benefits of meta programming.
• Recognize how meta programming can streamline development and reduce redundancy.

Inversion of Control (IoC) is a design principle where the flow of control is inverted, meaning that the system, rather than the developer, dictates how components are instantiated and interact. This approach promotes loose coupling and greater modularity, allowing for more flexible, maintainable, and testable code within software.

• Understand the concept and benefits of Inversion of Control.
• Get to know examples of how IoC is implemented in modern software systems.
• Recognize how IoC contributes to better code maintainability and testability.

The Registry Pattern is a design pattern used to store and manage global objects or settings that need to be accessed throughout an application. By centralizing data and resources, this pattern helps reduce redundancy and improves maintainability, ensuring consistent access to shared resources across different parts of the system.

• Understand the concept and purpose of the Registry Pattern.
• Learn how to utilize the Registry Pattern for managing global objects.
• Recognize the benefits of using the Registry Pattern for code organization and efficiency.

Key/value storages are a simple and efficient way to store and retrieve data pairs, where each unique key is associated with a specific value. This method is particularly useful for handling configuration settings, caching, or other scenarios where fast and flexible data access is needed.

• Understand the concept of key/value storage.
• Recognize the advantages of key/value storage for performance and simplicity.

Relationship types, or cardinalities,  define the nature of associations between database entities, such as one-to-one, one-to-many, or many-to-many relationships. Understanding these relationships is key to structuring data effectively and ensuring that your TYPO3 system can manage complex data interactions accurately.

• Understand the different types of relationships (cardinalities).
• Learn how to implement and manage these relationships within a relational database.
• Recognize the implications of different relationship types for data integrity and application logic.

The Repository Design Pattern provides a way to abstract and manage data access, separating the data layer from the business logic. This pattern enables developers to handle database interactions in a clean, organized manner, promoting better code maintainability, testability, and scalability.

• Understand the concept and purpose of the Repository Design Pattern.
• Recognize the advantages of using the Repository Design Pattern for maintaining clean, testable, and scalable code.

Data sanitization involves cleaning and formatting input data to remove or neutralize any potentially harmful content before it is processed or stored. This practice is essential for preventing security vulnerabilities, such as injection attacks, and ensuring that the data used within the system is safe and reliable.

• Understand the concept and importance of data sanitization.
• Learn how to judge which input requires which type of sanitization.

Error and exception handling involves managing and responding to runtime errors or unexpected conditions that occur during the execution of code. Proper handling ensures that the system can gracefully recover from errors, provide meaningful feedback, and maintain stability, thereby enhancing the overall user experience and security.

• Understand the principles of error and exception handling.
• Learn how to implement effective error handling strategies.
• Recognize the importance of logging and debugging in managing exceptions and errors.

Debugging involves identifying and resolving errors or issues within the system, whether in custom code, extensions, or configuration. Effective debugging practices are essential for maintaining a stable and functional TYPO3 environment, allowing developers to quickly pinpoint problems and implement solutions.

• Understand the tools and techniques available for debugging.
• Recognize the importance of systematic debugging to ensure system stability.

Caching is a performance optimization technique that stores generated data temporarily, allowing for faster retrieval and reducing server load. By implementing effective caching strategies, software can work more efficiently, enhancing the user experience and improving overall responsiveness.

• Understand the role and benefits of caching.
• Recognize how caching impacts site performance and user experience.

Data validation ensures that the input data conforms to expected formats and rules before being processed or stored. This process is crucial for maintaining data integrity, security, and consistency across systems, helping to prevent errors and vulnerabilities.

• Understand the importance of data validation.
• Recognize common validation techniques and best practices to ensure data quality.

Package/Dependency Management involves managing external libraries and extensions that your project depends on, ensuring that they are correctly installed, updated, and compatible with your system. Proper management of packages and dependencies helps maintain system stability, simplifies updates, and reduces conflicts, ensuring smooth project development and deployment.

• Understand the importance of package and dependency management.
• Recognize best practices for maintaining compatibility and stability through effective dependency management.
• Understand the difference between development and runtime dependencies and their respective usage.

Convention over Configuration is a development paradigm that reduces the need for explicit configuration by relying on sensible defaults and established conventions. This approach streamlines the development process, allowing developers to focus on custom logic rather than extensive configuration, leading to faster and more consistent implementations.

• Understand the principle of Convention over Configuration.
• Learn how conventions simplify development.
• Recognize the benefits and limitations of using conventions over custom configuration.

Semantic Versioning is a standardized versioning system that assigns version numbers in a Major.Minor.Patch format, clearly indicating the nature of changes in each release. This method helps maintainers and users understand the scope and impact of updates, facilitating better decision-making and smoother transitions between versions.

• Understand the structure and rules of semantic versioning.
• Learn how to apply semantic versioning principles.
• Recognize the significance of each version component (Major, Minor, Patch) and its potential impact on system stability.

Code autoloading is a mechanism to automatically load additional classes and files at runtime when they are needed, without requiring manual inclusion. This approach streamlines development by reducing the need for repetitive code and ensures that only the necessary components are loaded, improving both performance and maintainability.

• Understand the concept and benefits of code autoloading.
• Recognize how autoloading contributes to cleaner code and improved performance.

Loose Coupling refers to the design principle where different components of the system are minimally dependent on each other. This approach enhances flexibility, making it easier to modify, replace, or extend individual parts of the system without affecting the entire application, leading to more maintainable and scalable software.

• Understand the concept and importance of loose coupling in software development.
• Learn how to design loosely coupled components.
• Recognize the benefits of loose coupling for maintainability, scalability, and ease of integration.

Events are a way to implement loosely coupled software. They allow for calling other code by raising events at defined points in the code, without knowing what code will actually be called for the event, allowing for very flexible architectures.

• Understand how event-based architectures work.
• Learn the principles of how events are implemented and used.

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

I know which role controllers play in the pattern.

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.

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.

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