Contentful is a headless content management system (headless CMS). It allows businesses to manage content centrally and deliver it flexibly to various channels—such as websites, apps, or digital displays—via APIs.
Traditional CMS platforms (like WordPress) handle both content management and content presentation (e.g., rendering on a website). A headless CMS separates the content backend from the presentation frontend—hence the term “headless,” as the “head” (the frontend) is removed.
Flexible content modeling: You can define your own content types (e.g., blog posts, products, testimonials) with customizable fields.
Multi-language support: Well-suited for managing multilingual content.
Cloud-based: No server maintenance needed.
Integration-friendly: Works well with tools like React, Vue, Next.js, Shopify, SAP, etc.
Companies with multiple delivery channels (websites, apps, smartwatches, etc.)
Large brands with global content needs
Developer teams seeking a scalable and flexible CMS
A Headless CMS (Content Management System) is a system where the backend (content management) is completely separated from the frontend (content presentation).
Backend and frontend are tightly coupled.
You create content in the system and it's rendered directly using built-in themes and templates with HTML.
Pros: All-in-one solution, quick to get started.
Cons: Limited flexibility, harder to deliver content across multiple platforms (e.g., website + mobile app).
Backend only.
Content is accessed via an API (usually REST or GraphQL).
The frontend (e.g., a React site, native app, or digital signage) fetches the content dynamically.
Pros: Very flexible, ideal for multi-channel content delivery.
Cons: Frontend must be built separately (requires more development effort).
Websites built with modern JavaScript frameworks (like React, Next.js, Vue)
Mobile apps that use the same content as the website
Omnichannel strategies: website, app, smart devices, etc.
Contentful
Strapi
Sanity
Directus
Prismic
Storyblok (a hybrid with visual editing capabilities)
Data Manipulation Language (DML) is a subset of SQL (Structured Query Language) used to manage and manipulate data within a database. With DML, users can insert, query, update, and delete data — essentially everything you'd typically do with data stored in a database.
| Command | Purpose |
|---|---|
SELECT |
Retrieve data from a table |
INSERT |
Add new data |
UPDATE |
Modify existing data |
DELETE |
Remove data |
-- Insert
INSERT INTO customers (name, city) VALUES ('Müller', 'Berlin');
-- Query
SELECT * FROM customers WHERE city = 'Berlin';
-- Update
UPDATE customers SET city = 'Hamburg' WHERE name = 'Müller';
-- Delete
DELETE FROM customers WHERE name = 'Müller';DML deals with the data inside tables, not with the structure of the tables themselves (that's handled by Data Definition Language, DDL).
DML operations can often be rolled back (undone), especially when transactions are supported.
In short: DML is the toolset you use to keep your database dynamic and interactive by constantly adding, reading, modifying, or deleting data.
Doctrine DBAL (Database Abstraction Layer) is a PHP library that provides an abstraction layer for database access. It is part of the Doctrine project (a popular ORM for PHP), but it can be used independently of the ORM.
Doctrine DBAL offers a unified API to interact with different databases (such as MySQL, PostgreSQL, SQLite, etc.) without writing raw SQL specific to each database system.
Easily configure and manage connections to various database systems.
Supports connection pooling, transactions, and more.
Build SQL queries programmatically using an object-oriented API:
$qb = $conn->createQueryBuilder();
$qb->select('u.id', 'u.name')
->from('users', 'u')
->where('u.age > :age')
->setParameter('age', 18);
$stmt = $qb->executeQuery();Database Independence
The same code works with different database systems (e.g., MySQL, PostgreSQL) with minimal changes.
Schema Management
Tools to create, update, and compare database schemas.
Useful for migrations and automation.
Data Type Conversion
Automatically converts data between PHP types and database-native types.
use Doctrine\DBAL\DriverManager;
$conn = DriverManager::getConnection([
'dbname' => 'test',
'user' => 'root',
'password' => '',
'host' => 'localhost',
'driver' => 'pdo_mysql',
]);
$result = $conn->fetchAllAssociative('SELECT * FROM users');You might choose DBAL without ORM if:
You want full control over your SQL.
Your project doesn't need complex object-relational mapping.
You're working with a legacy database or custom queries.
Doctrine DBAL is a powerful tool for clean, portable, and secure database access in PHP. It sits between raw PDO usage and a full-featured ORM like Doctrine ORM, making it ideal for developers who want abstraction and flexibility without the overhead of ORM logic.
An INNER JOIN is a term used in SQL (Structured Query Language) to combine rows from two (or more) tables based on a related column between them.
You have two tables:
Table: Customers
| CustomerID | Name |
|---|---|
| 1 | Anna |
| 2 | Bernd |
| 3 | Clara |
Table: Orders
| OrderID | CustomerID | Product |
|---|---|---|
| 101 | 1 | Book |
| 102 | 2 | Laptop |
| 103 | 4 | Phone |
Now you want to know which customers have placed orders. You only want the customers who exist in both tables.
SELECT Customers.Name, Orders.Product
FROM Customers
INNER JOIN Orders ON Customers.CustomerID = Orders.CustomerID;| Name | Product |
|---|---|
| Anna | Book |
| Bernd | Laptop |
Clara didn’t place any orders → not included.
The order with CustomerID 4 doesn’t match any customer → also excluded.
An INNER JOIN returns only the rows with matching values in both tables.
Salesforce Apex is an object-oriented programming language specifically designed for the Salesforce platform. It is similar to Java and is primarily used to implement custom business logic, automation, and integrations within Salesforce.
Cloud-based: Runs exclusively on Salesforce servers.
Java-like Syntax: If you know Java, you can learn Apex quickly.
Tightly Integrated with Salesforce Database (SOQL & SOSL): Enables direct data queries and manipulations.
Event-driven: Often executed through Salesforce triggers (e.g., record changes).
Governor Limits: Salesforce imposes limits (e.g., maximum SOQL queries per transaction) to maintain platform performance.
Triggers: Automate actions when records change.
Batch Processing: Handle large data sets in background jobs.
Web Services & API Integrations: Communicate with external systems.
Custom Controllers for Visualforce & Lightning: Control user interfaces.
Memcached is a distributed in-memory caching system commonly used to speed up web applications. It temporarily stores frequently requested data in RAM to avoid expensive database queries or API calls.
Key-Value Store: Data is stored as key-value pairs.
In-Memory: Runs entirely in RAM, making it extremely fast.
Distributed: Supports multiple servers (clusters) to distribute load.
Simple API: Provides basic operations like set, get, and delete.
Eviction Policy: Uses LRU (Least Recently Used) to remove old data when memory is full.
Caching Database Queries: Reduces load on databases like MySQL or PostgreSQL.
Session Management: Stores user sessions in scalable web applications.
Temporary Data Storage: Useful for API rate limiting or short-lived data caching.
Memcached: Faster for simple key-value caching, scales well horizontally.
Redis: Offers more features like persistence, lists, hashes, sets, and pub/sub messaging.
sudo apt update && sudo apt install memcached
sudo systemctl start memcachedIt can be used with PHP or Python via appropriate libraries.
A Single Page Application (SPA) is a web application that runs entirely within a single HTML page. Instead of reloading the entire page for each interaction, it dynamically updates the content using JavaScript, providing a smooth, app-like user experience.
✅ Faster interactions after the initial load
✅ Improved user experience (no full page reloads)
✅ Offline functionality possible via Service Workers
❌ Initial load time can be slow (large JavaScript bundle)
❌ SEO challenges (since content is often loaded dynamically)
❌ More complex implementation, especially for security and routing
Popular frameworks for SPAs include React, Angular, and Vue.js.
Jest is a JavaScript testing framework developed by Meta (Facebook). It is mainly used for testing JavaScript and TypeScript applications, especially React applications, but it also works well for Node.js backends.
// sum.js
function sum(a, b) {
return a + b;
}
module.exports = sum;
// sum.test.js
const sum = require('./sum');
test('addiert 1 + 2 und ergibt 3', () => {
expect(sum(1, 2)).toBe(3);
});o run the test, use:
jestOr, if installed locally in a project:
npx jestThe Model is the data and logic layer in the MVC architecture. It manages the application's data and ensures that it is correctly stored, retrieved, and processed.
✅ Data Management: Stores and handles data, often in a database.
✅ Business Logic: Contains rules and calculations (e.g., discount calculation for orders).
✅ Data Validation: Checks if input is correct (e.g., if an email address is valid).
✅ Database Communication: Performs CRUD operations (Create, Read, Update, Delete).
class BlogPost extends Model {
protected $fillable = ['title', 'content']; // Erlaubte Felder für Massenverarbeitung
// Beziehung: Ein Blogpost gehört zu einem Benutzer
public function user() {
return $this->belongsTo(User::class);
}
}🔹 fillable: Specifies which fields can be saved.
🔹 belongsTo(User::class): Indicates that each blog post belongs to a user.
✔ The Model handles all data and business logic of the application.
✔ It ensures a clear separation between data and presentation.
✔ Changes to the data structure only need to be made in the Model, not throughout the entire application.
Tailwind CSS
