Study guide · Projects and Development Process

Steering TYPO3 projects: From the wish list to a safe go-live

As of November 15, 2026 · TYPO3 14.3 LTS · about 25 min read

A TYPO3 project rarely fails because of technology, far more often because of unclear requirements, wrong priorities and chaotic workflows. As a consultant or project manager, you are the bridge between the client and the team. On this page you follow a relaunch from the first workshop to the go-live. Afterwards you know agile methods, tools for requirements analysis and the basics of professional development.

Working agile: the manifesto and the waterfall

Our example is the Seetal holiday region. Within six months, the tourism association wants a new website with accommodation search, event calendar, hiking map and online booking. An agency builds it with Scrum. After the launch, a maintenance team takes over with Kanban.

In the classic waterfall model, the phases run one after another: analysis, design, implementation, testing and acceptance. The requirements are fixed completely at the start. The client often sees the result late, and later changes are costly.

Agile software development works in short iterations. The team delivers usable results regularly, gets feedback and adapts the plan to new insights. Agile teams plan too, just in short cycles. Agile fits when the requirements only become clear during the project, as with many websites. The waterfall fits better when the requirements are stable and fully known. So the right approach depends on the project, the team and the client. Well-known agile frameworks are Scrum and Kanban.

The foundation is the Manifesto for Agile Software Development. A group of 17 software developers wrote it in February 2001 at a meeting in Utah. It names four values:

  • Individuals and interactions over processes and tools.
  • Working software over comprehensive documentation.
  • Customer collaboration over contract negotiation.
  • Responding to change over following a plan.

The sentence that follows matters: there is value in the items on the right, but the items on the left are valued more. So the manifesto forbids neither documentation nor planning. Both should serve the result.

On top of that come twelve principles. Here are some of them:

  • Working software is delivered frequently, within a couple of weeks to a couple of months, preferably at shorter intervals.
  • Changing requirements are welcome, even late in development.
  • Business people and developers work together daily, ideally face to face.
  • Working software is the primary measure of progress.
  • The team keeps a sustainable pace and reflects regularly on how to become more effective.

Describing requirements properly

In the first workshop, you collect the association's wishes. This is where requirements engineering begins. It has three tasks:

  • You elicit requirements, for example in workshops and interviews with the stakeholders.
  • You document, prioritize and agree on them with everyone involved.
  • You manage changes and trace each requirement through to implementation and testing.

Writing code or setting up servers is not part of it, but stakeholder management is. For Seetal, the stakeholders are management, marketing, local tourist offices, hosts, guests, data protection and IT. All relevant views should be heard.

Functional requirements describe what the system should do. Examples: visitors can subscribe to the newsletter or submit a contact form, and editors can create news. Non-functional requirements describe qualities such as performance, security, accessibility and availability. Examples: the home page loads on a smartphone in under two seconds. The website meets WCAG 2.2 at level AA. It is available 99.9 percent of the year. A complete description needs both kinds.

Agile teams like to write requirements as a user story. The pattern is: as a role, I want to reach a goal, so that I get a benefit. It comes with acceptance criteria. These are testable conditions that must be met for the story to count as done. They make the requirement unambiguous and help with estimating, building and accepting it.

One rule saves a lot of trouble: every requirement and every bug gets its own ticket. Collective tickets mix topics, make estimating, prioritizing and accepting harder, and hide what is done. With one ticket per item, you track responsibility, status and implementation separately. This creates a clear trail from the requirement to the test.

Prioritizing with MoSCoW and the Kano model

Budget and time are never enough for everything. The MoSCoW method sorts requirements into Must, Should, Could and Won't, meaning “not this time”. This separates the essential from the desirable and from what is deliberately postponed. It helps especially with a fixed budget or deadline. Must should really only contain what is necessary.

The Kano model describes how different features of a product affect customer satisfaction. In practice, four kinds of features matter most:

  • Basic features are taken for granted. If they are missing, the customer is dissatisfied. If they are there, nobody praises them. Examples are a working search, a working contact form and a mobile layout.
  • Performance features raise satisfaction in proportion to how well they are met. The faster the page loads, the happier the guests.
  • Delighters, also called excitement features, are not expected by anyone. If they are there, they surprise people in a positive way.
  • Indifferent features hardly affect satisfaction at all.
satisfied dissatisfied not fulfilled fulfilled Delighter surprises, nobody misses it Performance the more, the happier Basic missing means annoyed Over time, delighters become performance and basic features.
The Kano model: three kinds of features affect satisfaction in very different ways.

For Seetal, this means: the working contact form is a basic feature, and the faster loading time is a performance feature. An AI-powered holiday advisor that nobody expects is a delighter. How the target group really classifies a feature is found out with a survey. Each feature is asked about in a functional and a dysfunctional way. That means how it would be if it is there, and how it would be if it is missing.

Delight does not last forever. Customers get used to it, and what surprises today is expected tomorrow. Over time, delighters become performance or basic features. A mobile view used to be an extra, today it is a must. That is why you reassess requirements regularly.

Scrum: accountabilities, sprints and artifacts

The agency works with Scrum, a lightweight framework for complex products, following the Scrum Guide from 2020. A Scrum Team usually has ten or fewer people and three accountabilities, formerly called roles:

  • The Product Owner maximizes the value of the product. They are accountable for the content and order of the Product Backlog. They can delegate work but remain accountable.
  • The Scrum Master promotes the understanding of Scrum, coaches the team and the organization, and helps remove impediments.
  • The Developers, formerly called the Development Team, create a usable increment in every sprint. They decide for themselves how to reach the Sprint Goal. The Product Owner does not dictate their technical way of working.

The rhythm is called a sprint: a fixed period of one month at most, often two weeks. At the end there is a usable increment. The sprint contains all other events. The maximum durations apply to a one-month sprint. For shorter sprints, the events are shorter.

  • In Sprint Planning, the team decides what it can achieve in the sprint, how it will proceed and what the Sprint Goal is. It lasts up to eight hours.
  • The Daily Scrum is a daily meeting of the Developers that lasts 15 minutes. They check progress towards the Sprint Goal and plan the next day. It is not a status report to management. Longer discussions come afterwards.
  • In the Sprint Review, the Scrum Team inspects the result with the stakeholders and adapts the next steps. The feedback flows into the Product Backlog. It lasts up to four hours.
  • The Sprint Retrospective concludes the sprint. There the team improves collaboration, processes and quality. It lasts up to three hours.

A steering committee is not part of Scrum. Stakeholders mainly have their say in the Sprint Review.

Product Backlog Commitment: Product Goal Sprint Planning, up to 8 h Sprint Backlog Commitment: Sprint Goal Sprint, one month at most Daily Scrum 15 minutes every day Increment Commitment: Definition of Done Sprint Review with stakeholders, 4 h Retrospective team improves, 3 h All events are part of the sprint. Times apply to a sprint of one month.
A sprint with its events and artifacts. Each artifact has its commitment.

Scrum has three artifacts, each with a commitment:

  • The Product Backlog is the ordered list of all work on the product. Its commitment is the Product Goal.
  • The Sprint Backlog contains the work of the sprint. Its commitment is the Sprint Goal.
  • The increment is the usable result. Its commitment is the Definition of Done. It defines when an increment is finished and creates a shared understanding of quality.

Requirement specifications and Gantt charts, on the other hand, come from classic project management.

Scrum in everyday client work

In the middle of the third sprint, the head of marketing calls. She urgently needs a page for a new lake festival. In Scrum, the team does not cancel the sprint for this, and nobody works extra at night. The Product Owner adds the wish to the Product Backlog and prioritizes it. The Sprint Goal stays stable. The team may adjust the Sprint Backlog with the Product Owner, as long as the Sprint Goal is not at risk. If the Sprint Goal becomes obsolete, only the Product Owner can cancel the sprint.

Scrum brings focus, early feedback and transparency. As a consultant, however, you also know its limits:

  • The fixed events take time and require discipline.
  • Without a Product Owner on the client side who can make decisions, Scrum loses much of its effect.
  • Fixed-price projects with a completely fixed scope fit poorly with Scrum.
  • For pure maintenance with many small tickets, Scrum is often too rigid.

Scrum does not forbid documentation. It is allowed as long as it creates value. And three accountabilities do not mean three people. A Scrum Team usually has ten or fewer members.

Kanban and Kaizen

After the go-live, the maintenance team takes over. Now tickets come in all the time: bugs, small wishes, urgent corrections. Kanban fits this. It works without fixed iterations and without prescribed roles. Work is pulled as soon as capacity is free. The Kanban Guide from 2025 names three practices: defining and visualizing the workflow, actively managing the items in it, and improving the workflow. In short, they look like this.

  • Visualize the work: A Kanban board is a board with columns for the work steps, such as “To do”, “In progress”, “Review” and “Done”. Cards move through the columns and show the status of each task. Everyone sees the progress, and bottlenecks stand out.
  • Limit work in progress: WIP stands for work in progress, meaning work that has started but is not finished. A WIP limit caps the number of tasks worked on at the same time in one work step. This stops the team from starting too much at once, and tasks get finished faster.
  • Manage the flow and keep improving: The team watches metrics such as throughput, the age of open items and the cycle time from start to finish. With them, it improves its workflow.

For the Seetal support team, Kanban is ideal: a visible board, WIP limits against overload and a separate lane with clear rules for urgent cases. Scrum with four-week sprints in which no new tickets are accepted is a poor fit here. Scrum bundles work into sprints with fixed accountabilities and events, which suits building a product. Kanban works continuously and steers the flow through WIP limits, which suits maintenance and support. Both are agile and can be combined.

Behind both is Kaizen. The word comes from Japan and roughly means change for the better. It stands for continuous improvement in small steps instead of a one-time major restructuring. In Scrum, Kaizen lives in the retrospective. In Kanban, it lives in the ongoing improvement of the workflow.

Git and Composer: keeping code and packages under control

Professional development is built on a version control system, in TYPO3 projects almost always Git. Git saves every change as a commit with an author and a description. So you can trace who changed what and when. The team works on the code together and can return to an earlier state at any time.

A branch is a separate line of development in which changes are made apart from the main line, for example for the event calendar. After review and tests, a merge brings it back in. Platforms such as GitHub or GitLab support this with pull requests or merge requests.

Git is distributed: every working copy contains the complete history. Commits are made locally and later synchronized with a shared repository. So you can also work without a central server.

In a Composer-based TYPO3 project, the repository holds the files composer.json and composer.lock, the site configuration in config/sites, your own extensions and the site package. These do not belong in it:

  • The vendor folder, because Composer restores it from the file composer.lock.
  • Credentials and secrets of each environment, for example in a file called .env.
  • The files that editors upload to fileadmin. They are backed up like the database, not versioned.

The package manager for TYPO3 projects is Composer. It manages PHP packages such as the TYPO3 Core, extensions and libraries, resolves their dependencies and generates the autoloader. For frontend tools, people often also use npm or yarn. Programs like apt or Homebrew, by contrast, install system software.

The file composer.json describes which packages you want and in which version ranges. The file composer.lock records the exact installed versions. The command composer install installs exactly these, for example during deployment. So all environments use the same versions, and the lock file belongs in version control.

"require": {
    "typo3/cms-core": "^14.3"
}
Excerpt from a composer.json. The project requires the package typo3 cms-core with the version caret 14.3.

The caret in front of 14.3 allows all versions from 14.3.0 up to, but not including, 15.0.0. These are compatible updates according to semantic versioning, but no new major version. You get patch releases such as 14.3.7, but no automatic upgrade to TYPO3 15.

The advantage of package managers: dependencies are resolved and updated automatically. The drawback: you depend on external package sources such as Packagist and on their availability, and you need to understand version conflicts. Composer does not replace version control.

From local to live: environments and CI and CD

A professional workflow separates three environments:

  • In development, usually local with DDEV or Docker, you build and try things out.
  • On staging, you test and accept. This environment resembles the live system as closely as possible.
  • Production, also called the live environment, is the public website.

This way, bugs are found before visitors see them. The TYPO3 security guidelines also recommend developing and testing new things on staging servers.

Local development for example with DDEV Git commit, branch, review CI tests and code checks CD Staging acceptance by the client CD Live production, public Edit directly on live untested, not versioned Every change takes the same path.
Every change takes the same path. The direct route to the live server is blocked.

The client asks you to adjust a template directly on the live server, “just quickly”. That carries several risks:

  • Bugs hit all visitors immediately, because nothing was tested beforehand.
  • The change is missing from version control and is overwritten by the next deployment.
  • Later, nobody can trace who changed what.

So it is technically possible, but it bypasses testing, review and the deployment process.

CI stands for continuous integration: after every push, tests and checks run automatically. CD stands for continuous delivery or continuous deployment: checked versions are rolled out to staging or live automatically. Typical tools are pipelines in GitHub or GitLab, or Deployer. With continuous delivery, every checked version can be released at any time, but a person often triggers the last step to live. With continuous deployment, this step is automatic too. Compared with manual uploads, this brings three advantages:

  • Every delivery runs the same way and can be repeated, and no step is forgotten.
  • Tests and checks run automatically before the rollout.
  • You can quickly roll back to an earlier state.

Do not modify third-party code

Changing the code of the TYPO3 Core or of third-party extensions directly is almost always wrong. It is not forbidden, because the GPL license allows changes. But modified third-party code is hard to maintain. With the next update, the change is overwritten. Or the team no longer dares to update and gets stuck on old, insecure versions. Stability suffers.

Use the intended extension points instead: PSR-14 events, TypoScript, TSconfig, your own extensions and overriding templates. Everything stays in version control, so you can go back quickly.

Assuring quality: tests, rules and documentation

Finally, the association wants to save budget and skip tests. Then you need arguments. First, the kinds of tests:

  • A unit test checks a single, small unit of code, such as a function, quickly and in isolation.
  • A functional test, also called an integration test, checks the interaction with the framework and the database.
  • An acceptance test, also called a system test, checks the whole application from the user's point of view in the browser.

The TYPO3 Testing Framework supports all three. Manual tests complement them but do not replace them, and tests only after the launch come too late.

Automated tests find bugs early and repeatably, with every change and every update. They often run in CI and reveal regressions immediately. They do not replace acceptance by the client, and documentation is still needed.

Coding guidelines are shared rules for formatting and structure. They ensure consistent, readable code that everyone can understand and maintain more easily. TYPO3 has its own coding guidelines, which are based on PHP standards. Tools check them automatically, for example in CI. Documentation of code, configuration and operations preserves knowledge so that it does not depend on individuals.

Key points

  • Agile means short iterations with feedback. The waterfall works through phases one after another.
  • The Agile Manifesto from 2001 names four values and twelve principles. The items on the right have value, those on the left more.
  • Functional requirements say what the system does, non-functional ones how well.
  • User stories with acceptance criteria, one ticket per requirement, prioritizing with MoSCoW and Kano.
  • Scrum: Product Owner, Scrum Master and Developers, a sprint of one month at most, three artifacts.
  • Kanban: visualize, limit WIP, manage the flow. Kaizen means improvement in small steps.
  • Git versions the code, Composer the packages, and the lock file records the exact versions.
  • Never change things directly on live. Leave third-party code alone and use extension points or a patch.

Terms

Acceptance criterion
Testable condition for a requirement to count as done.
Branch
Separate line of development in Git.
Definition of Done
Shared criteria for when an increment is finished.
Increment
Usable result of a sprint.
Kaizen
Continuous improvement in small steps.
Staging
Test environment that resembles the live system as closely as possible.
WIP limit
Upper limit for tasks started at the same time in one work step.

As of: November 15, 2026 (TYPO3 14.3 LTS)

Sources:

  • Manifesto for Agile Software Development and the twelve principles (agilemanifesto.org, 2001)
  • The Scrum Guide, November 2020 (Schwaber, Sutherland)
  • The Kanban Guide, May 2025
  • TYPO3 Explained 14.3, chapters on version control with Git, Composer, deployment, environments and testing
  • Learning objectives TYPO3 CMS Certified Consultant 14 LTS, area projects and development process

This study guide was written with AI and checked against the sources.

Certifications & exams

Which exam comes next?

You can already practise for 51 exams, and 16 are up for a vote. See all certifications with their official information, cast your vote or suggest your exam.

See all certifications