Extbase quick start for experienced developers 

Step 1: Scaffold the extension 

Use the FriendsOfTYPO3 kickstarter package to generate the extension skeleton:

composer require friendsoftypo3/kickstarter --dev
vendor/bin/typo3 make:extension

Answer the prompts (vendor name, extension key, etc.). The kickstarter generates the directory structure, composer.json and the boilerplate files you need. Since TYPO3 v14 you do not need ext_emconf.php unless you plan to publish your extension to the TYPO3 Extension Repository.

Step 2: Create the domain model 

Add a class extending \TYPO3\CMS\Extbase\DomainObject\AbstractEntity to Classes/Domain/Model/. Properties map to database columns by name.

<?php

declare(strict_types=1);

namespace MyVendor\MyExtension\Domain\Model;

use TYPO3\CMS\Extbase\DomainObject\AbstractEntity;

class Conference extends AbstractEntity
{
    protected string $title = '';
    protected string $description = '';
    protected ?\DateTimeImmutable $conferenceDate = null;

    public function getTitle(): string
    {
        return $this->title;
    }

    public function getDescription(): string
    {
        return $this->description;
    }

    public function getEventDate(): ?\DateTimeImmutable
    {
        return $this->conferenceDate;
    }
}

Key points:

• Declare properties protected. Public properties also work and can keep the model shorter (no getters/setters), but protected keeps the door open for getter/setter logic and makes lazy-loaded relations easier to reason about. Private properties are never populated by Extbase — use protected, not private.
• Do not initialise properties in the constructor. Extbase populates them directly when loading objects from the database, bypassing the constructor.
• Use typed properties. Extbase reads the type declarations to map values correctly.

Step 3: Create the repository 

For a basic repository, extending \TYPO3\CMS\Extbase\Persistence\Repository is all you need. The naming convention is mandatory: a model named Conference must have a repository named ConferenceRepository in the \Domain\Repository namespace.

<?php

declare(strict_types=1);

namespace MyVendor\MyExtension\Domain\Repository;

class ConferenceRepository extends \TYPO3\CMS\Extbase\Persistence\Repository {}

The base class provides findAll(), findByUid(), findBy(array $criteria), and findOneBy(array $criteria) out of the box.

Step 4: Define the database table (TCA) 

Create Configuration/TCA/tx_myextension_domain_model_conference.php with the column definitions matching your model properties.

Since TYPO3 v13, database columns are auto-created from TCA definitions — you no longer need to define every field in ext_tables.sql. Check the database analyser after installation to confirm the generated schema matches your expectations. If a column needs a non-default type or index, declare it explicitly in ext_tables.sql and it will take precedence.

The TCA column names must match the property names of your model (camelCase properties map to snake_case columns by default — for example $conferenceDate maps to conference_date).

Step 5: Create the controller 

Controllers live in Classes/Controller/ and extend \TYPO3\CMS\Extbase\Mvc\Controller\ActionController . Each public method ending in Action is automatically available as a plugin action. Use dependency injection to receive dependencies via the constructor. In Extbase, repositories and other services are injected this way — see also Injecting repositories with dependency injection.

<?php

declare(strict_types=1);

namespace MyVendor\MyExtension\Controller;

use MyVendor\MyExtension\Domain\Model\Conference;
use MyVendor\MyExtension\Domain\Repository\ConferenceRepository;
use Psr\Http\Message\ResponseInterface;
use TYPO3\CMS\Extbase\Mvc\Controller\ActionController;

class ConferenceController extends ActionController
{
    public function __construct(
        protected readonly ConferenceRepository $conferenceRepository,
    ) {}

    public function listAction(): ResponseInterface
    {
        $this->view->assign('conferences', $this->conferenceRepository->findAll());
        return $this->htmlResponse();
    }

    public function showAction(
        Conference $conference,
    ): ResponseInterface {
        $this->view->assign('conference', $conference);
        return $this->htmlResponse();
    }
}

• Assign variables to the view with $this->view->assign().
• Return $this->htmlResponse() to render the Fluid template.
• Typed action arguments are automatically resolved from the request — passing a UID in the URL results in a fully populated Conference object in the action. Extbase loads it from the repository for you.

Step 6: Add Fluid templates 

Create the template files Extbase expects by convention:

The template name matches the action name — for example listAction() maps to List.fluid.html. Variables assigned in the controller are available directly in the template.

<f:for each="{conferences}" as="conference">
    <h2>{conference.title}</h2>
    <p>{conference.conferenceDate -> f:format.date(format: 'd.m.Y')}</p>
    <f:link.action action="show" arguments="{conference: conference}">
        Read more
    </f:link.action>
</f:for>

Step 7: Register the plugin 

Two calls are required — one in ext_localconf.php, one in Configuration/TCA/Overrides/tt_content.php.

Since TYPO3 v14, plugins are registered as dedicated content types ( CType).

ext_localconf.php tells Extbase which controller actions the plugin may call:

<?php

declare(strict_types=1);

use MyVendor\MyExtension\Controller\ConferenceController;
use TYPO3\CMS\Extbase\Utility\ExtensionUtility;

defined('TYPO3') or die();

ExtensionUtility::configurePlugin(
    'MyExtension',
    'ConferenceList',
    [
        ConferenceController::class => ['list', 'show'],
    ],
);

Configuration/TCA/Overrides/tt_content.php registers the plugin as a content element in the backend:

<?php

declare(strict_types=1);

use TYPO3\CMS\Extbase\Utility\ExtensionUtility;

defined('TYPO3') or die();

ExtensionUtility::registerPlugin(
    'MyExtension',
    'ConferenceList',
    'LLL:EXT:my_extension/Resources/Private/Language/locallang.xlf:plugin.conferencelist.title',
    'EXT:my_extension/Resources/Public/Icons/Extension.svg',
);

Step 8: Configure routing (optional but recommended) 

Without a route enhancer, URLs contain the raw plugin namespace parameters (for example: ?tx_myextension_conferencelist[action]=show&tx_myextension_conferencelist[conference]=5). Add an Extbase route enhancer to your site configuration to get clean URLs like /conferences/my-conference.

routeEnhancers:
  ConferenceList:
    type: Extbase
    extension: MyExtension
    plugin: ConferenceList
    defaultController: 'Conference::list'
    routes:
      - routePath: '/conferences'
        _controller: 'Conference::list'
      - routePath: '/conferences/{conference}'
        _controller: 'Conference::show'
    aspects:
      conference:
        type: PersistedAliasMapper
        tableName: tx_myextension_domain_model_conference
        routeFieldName: slug

Step 9: Install and try it 

Install your extension if it is not already active. In a Composer-based project, require it first:

composer require myvendor/my-extension

In non-composer-based projects, the extension is already in place, as you develop it within the code base. In both cases, you need to activate it:

vendor/bin/typo3 extension:activate my_extension

Then in the TYPO3 backend:

1. Create a sysfolder page and add your conference records there.
2. Create or edit a regular page, add a content element, and select your plugin from the content element type list.
3. Set the Record Storage Page on the plugin content element to the sysfolder from step 1 (or configure plugin.tx_myextension.persistence.storagePid in TypoScript).
4. Open the page in the frontend — you should see your list view.

If the list is empty, check the storagePid first. See storagePid — when findAll() returns nothing.

What next? 

You have a working extension. From here:

• Core concepts of Extbase — understand the MVC and ORM patterns underlying everything above.
• Querying the database with Extbase — write custom repository queries with ordering, filtering, and limits.
• Validation in Extbase — validate model properties and action arguments automatically.
• Caching for Extbase plugins — understand how caching works for your plugin and what your responsibilities are.