Wenn deine Agentur immer mehr Kunden hat, kann es schnell zu einer Herausforderung werden, eine hohe Leistung für alle von dir verwalteten Websites zu gewährleisten. Schlecht programmierte Plugins, nicht optimierte Bilder und Skripte von Drittanbietern können die Websites deiner Kunden verlangsamen und die PageSpeed Insights (PSI)-Werte nach und nach senken.

Anstatt jede einzelne WordPress-Website manuell zu überprüfen, kannst du die Leistungsüberwachung für alle deine Websites automatisieren und dich darauf konzentrieren, Anomalien nur dann zu untersuchen, wenn sie auftreten. So spart dein Team durch einfache, effiziente automatisierte Prüfungen jeden Monat Stunden an Arbeit.

In diesem Artikel erfährst du, wie du die Überwachung der Leistung aller von Kinsta gehosteten WordPress-Websites deiner Agentur automatisieren kannst, indem du die Kinsta-API und die Google PageSpeed Insights API zusammen nutzt. Im letzten Schritt erfährst du, wie du diese Daten mit Hilfe von Slack-Webhooks in Echtzeit mit deinem Team teilen und den Prozess mit einem Cron-Job automatisieren kannst.

Aufregend, oder? Dann lass uns loslegen.

Workflow-Übersicht: Kinsta zu PageSpeed Insights zu Slack

Das Skript verknüpft drei APIs. Kinsta, Google PageSpeed Insights und Slack, um die Überwachung der Website-Leistung zu automatisieren.

Beginne mit einer Abfrage der Kinsta-API, um deine Website-Domains und -Umgebungen abzurufen. So wird sichergestellt, dass deine Domainliste immer auf dem neuesten Stand ist, wenn du Kunden-Websites hinzufügst.

Dann verwendet dein Skript für jede Website, die von der Kinsta-API zurückgegeben wird, die Google PSI-API, um die wichtigsten Kennzahlen zu ermitteln: Performance Score (0-100), First Contentful Paint (FCP) und Largest Contentful Paint (LCP).

Zum Schluss postet das Skript diese Kennzahlen, den Namen der Website, die drei Werte und einen PageSpeed Insights-Link an einen bestimmten Slack-Kanal.

Einrichten der Tools

Bevor du mit dem Programmieren beginnst, solltest du zwei API-Schlüssel generieren und eine schnelle Konfiguration vornehmen.

Verwendung der Kinsta-API: Überprüfe die Berechtigungen und generiere deinen API-Schlüssel

Für die Kinsta-API wird ein API-Schlüssel benötigt, der von einem Konto mit bestimmten Berechtigungen generiert wird. In unserem Beispiel sollte es der Firmeninhaber oder ein Firmenadministrator sein.

Um einen Kinsta-API-Schlüssel zu erstellen, melde dich bei MyKinsta an und befolge diese Schritte:

  • Navigiere zur Seite mit den API-Schlüsseln (Dein Name > Unternehmenseinstellungen > API-Schlüssel).
  • Klicke auf API-Schlüssel erstellen.
  • Lege die Gültigkeitsdauer fest und gib deinem Schlüssel einen eindeutigen Namen.
  • Klicke auf Erzeugen.
Erstelle einen API-Schlüssel in MyKinsta.
Erstelle einen API-Schlüssel in MyKinsta.

Beachte, dass dies das einzige Mal ist, dass du deinen API-Schlüssel sehen kannst. Kopiere ihn und bewahre ihn an einem sicheren Ort auf.

Das zweite, was du brauchst, ist deine MyKinsta-Unternehmens-ID. Du kannst sie leicht im Query-String deiner MyKinsta-Dashboard-URL finden (suche nach dem Parameter idCompany).

Mit diesen Daten kannst du auf die Kinsta-API zugreifen und mit cURL eine Liste deiner Unternehmensseiten abfragen. Öffne dein bevorzugtes Befehlszeilentool und gib den folgenden Befehl ein, wobei du <YOUR_COMPANY_ID> und <YOUR_API_KEY> durch deine Anmeldedaten ersetzt.

curl -X GET "https://api.kinsta.com/v2/sites?company=<YOUR_COMPANY_ID>" 
	 -H "Authorization: Bearer <YOUR_API_KEY>"

Wenn deine Unternehmens-ID und dein API-Schlüssel korrekt sind, solltest du eine JSON-Antwort erhalten, die wie folgt aufgebaut ist:

{
	"company": {
		"sites": [
			{
				"id": "YOUR_SITE_ID",
				"name": "my-wordpress-website",
				"display_name": "My WordPress website",
				"status": "live",
				"site_labels": []
			}
		]
	}
}

Wie du sehen kannst, fehlt in dieser Antwort eine wichtige Information – die URL der Website. Um die primäre Domäne für jede Umgebung abzurufen, fügst du den Parameter include_environments=true zum Abfrage-String hinzu. Mit diesem Parameter gibt die API auch detaillierte Daten für jede Umgebung (Live und Staging) zurück, einschließlich der primären Domäne. Hier ist eine allgemeine Antwort:

{
	"company": {
		"sites": [
			{
				"id": "54fb80af-576c-4fdc-ba4f-b596c83f15a1",
				"name": "firstsite",
				"display_name": "First site",
				"status": "live",
				"siteLabels": [
					{
						"id": "54fb80af-576c-4fdc-ba4f-b596c83f15a1",
						"name": "Do not remove"
					}
				],
				"environments": [
					{
						"id": "54fb80af-576c-4fdc-ba4f-b596c83f15a1",
						"name": "live",
						"display_name": "Live",
						"is_blocked": false,
						"id_edge_cache": "54fb80af-576c-4fdc-ba4f-b596c83f15a1",
						"cdn_cache_id": "54fb80af-576c-4fdc-ba4f-b596c83f15a1",
						"is_opt_out_from_automatic_php_update": false,
						"web_root": "/release_v1",
						"image_optimization_type": "lossy",
						"is_additional_sftp_accounts_enabled": false,
						"is_premium": false,
						"wordpress_version": "6.3.1",
						"domains": [ ... ],
						"primaryDomain": {
							"id": "54fb80af-576c-4fdc-ba4f-b596c83f15a1",
							"name": "example.com",
							"site_id": "54fb80af-576c-4fdc-ba4f-b596c83f15a1",
							"is_active": true,
							"type": "live"
						},
						"ssh_connection": { ... }
						},
						"container_info": { ... }
					}
				]
			}
		]
	}
}

Als Nächstes musst du eine Google PageSpeed Insights-Anwendung und einen API-Schlüssel erstellen.

Einen API-Schlüssel für Google PageSpeed Insights generieren

Im nächsten Schritt musst du einen API-Schlüssel für den Zugriff auf den Google PageSpeed Insights-Dienst erstellen. Melde dich in der Google Cloud Console an und befolge diese Schritte:

Schritt 1: Erstelle ein neues Projekt oder öffne ein bestehendes Projekt. Für diesen Artikel haben wir ein neues Performance Monitoring Projekt erstellt.

Die Seite des Performance Monitoring-Projekts in der Google Cloud-Konsole
Die Seite des Performance Monitoring-Projekts in der Google Cloud-Konsole

Schritt 2: Navigiere zu APIs & Dienste > Bibliothek, suche dann unten auf der Seite nach PageSpeed Insights API und klicke auf die Schaltfläche.

Google Cloud API Bibliothek
Wähle PageSpeed Insights API in der Google Cloud API-Bibliothek aus

Schritt 3: Auf der nächsten Seite klickst du auf Aktivieren.

PageSpeed Insights API aktivieren
PageSpeed Insights API aktivieren

Schritt 4: Klicke in der Registerkarte Anmeldeinformationen auf Anmeldeinformationen erstellen.

PSI-API-Anmeldeinformationen erstellen
PSI-API-Anmeldeinformationen erstellen

Schritt 5: Für zusätzliche Sicherheit empfehlen wir, den neu erstellten Schlüssel einzuschränken, indem du nur die PageSpeed Insights API auswählst.

Beschränkungen für PageSpeed Insights API festlegen
Beschränkungen für PageSpeed Insights API festlegen

Dein PageSpeed Insights API-Schlüssel ist nun einsatzbereit. Ein letzter Dienst muss noch konfiguriert werden. Du musst eine neue Slack-App erstellen.

Erstelle eine Slack-App und konfiguriere den Incoming Webhook

Um Nachrichten an einen bestimmten Slack-Kanal zu senden, musst du eine Slack-Anwendung erstellen. Befolge diese Schritte:

Schritt 1: Wenn du Slack aktiv nutzt, um mit deinem Team zusammenzuarbeiten, hast du einen aktiven Arbeitsbereich. Wenn nicht, schau in der Slack-Dokumentation nach, wie du einen erstellst. In diesem Beispiel gehen wir davon aus, dass du bereits einen Arbeitsbereich „Mein Unternehmen“ hast.

Schritt 2: Gehe zum Slack API Dashboard und klicke auf App erstellen (oder Neue App erstellen, wenn dies nicht deine erste App ist).

Slack API Dashboard
Erstelle deine erste Slack-App.

Schritt 3: Du wirst aufgefordert, die Bereiche und Einstellungen für deine App zu konfigurieren. Wähle From Scratch.

Erstelle eine Slack App von Grund auf.
Erstelle eine Slack App von Grund auf.

Schritt 4: Als Nächstes gibst du deiner Anwendung einen Namen (z.B. Performance Bot) und wählst deinen Arbeitsbereich.

App-Name wählen und einen Arbeitsbereich auswählen
App-Name wählen und einen Arbeitsbereich auswählen

Schritt 5: Wähle Incoming Webhooks in der linken Seitenleiste aus und klicke dann auf Ein. Dann klickst du unten auf der Seite auf Neuen Webhook hinzufügen.

Eingehende Webhooks aktivieren
Eingehende Webhooks aktivieren

Schritt 6: Kopiere die Webhook-URL und speichere sie für spätere Zwecke.

Webhook-URLs für deinen Arbeitsbereich
Webhook-URLs für deinen Arbeitsbereich

Du hast jetzt alles, was du brauchst, um ein Skript zu erstellen, mit dem du die Leistungsdaten deiner Website automatisch mit deinem Team auf Slack teilen kannst. Es ist an der Zeit, in den Code einzutauchen.

Ein PHP-Skript zur Automatisierung der Leistungsüberwachung

Im nächsten Schritt musst du ein Skript erstellen, das mit den drei oben genannten Diensten kommuniziert, um die Leistung aller auf Kinsta gehosteten Kundenseiten der Agentur automatisch zu überwachen.

Schritt 1: Skriptkonfiguration

Erstelle in deinem bevorzugten Code-Editor eine neue .php-Datei und füge den folgenden Code ein:

<?php

$kinsta_api_key	 = 'YOUR_KINSTA_API_KEY';
$kinsta_company_id  = 'YOUR_COMPANY_UUID';
$google_api_key	 = 'YOUR_GOOGLE_API_KEY';
$slack_webhook_url  = 'YOUR_SLACK_WEBHOOK_URL';

echo "--- STARTING PERFORMANCE MONITORING ---n";

Ersetze die Platzhalter durch deine tatsächlichen Daten, die du zuvor abgerufen hast.

Schritt 2: Verwende die Kinsta-API, um eine Liste der Unternehmensseiten abzurufen

Um die Liste der Websites in deinem Kinsta-Konto abzurufen, musst du die Kinsta API v2 und den Endpunkt /sites verwenden.

Hier erfährst du, wie du über cURL auf die API zugreifen kannst:

// 1. Fetch the list of sites from Kinsta
$url_kinsta = "https://api.kinsta.com/v2/sites?company=" . $kinsta_company_id . "&include_environments=true";
$ch = curl_init($url_kinsta);
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Authorization: Bearer ' . $kinsta_api_key]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$res_kinsta = curl_exec($ch);
$data_kinsta = json_decode($res_kinsta, true);
curl_close($ch);

$sites = $data_kinsta['company']['sites'] ?? [];
echo "Found " . count($sites) . " sites to analyze.n";

Beachte, dass wir den Abfrageparameter includes_environments=true verwendet haben, um die Umgebungsdetails (Live und Staging) abzurufen.

Als Nächstes fragst du die Google PSI API ab und sendest die Daten an die Slack-App.

PageSpeed Insights Metriken und Slack-Benachrichtigungen

Jetzt musst du die URL jeder abgerufenen Website an die PageSpeed Insights API senden. Wenn du den Dienst aufrufst, führt PageSpeed Insights eine Leistungsprüfung durch und gibt ein Objekt mit Leistungsdaten zurück. Dein Skript sendet diese Daten an die Slack-API, die dann die entsprechenden Nachrichten generiert.

Hier ist der Code, den du zu deinem Skript hinzufügen musst:

foreach ($sites as $site) {
	$site_label = $site['display_name'];
	$primary_domain = "";

	// 2. Search the downloaded data directly for the live environment
	$environments = $site['environments'] ?? [];

	foreach ($environments as $env) {
		if ($env['name'] === 'live') {
			$raw_domain = $env['primaryDomain'] ?? $env['primary_domain'] ?? null;
			$primary_domain = is_array($raw_domain) ? ($raw_domain['name'] ?? "") : $raw_domain;
			break;
		}
	}

	if (empty($primary_domain)) {
		echo "Skipping $site_label (No Live domain found).n";
		continue;
	}

	echo "Analyzing $primary_domain... ";

	// 3. PageSpeed analysis
	$psi_url = "https://www.googleapis.com/pagespeedonline/v5/runPagespeed?url=https://" . urlencode($primary_domain) . "&key=$google_api_key&category=performance&strategy=mobile";
	
	$res_psi = @file_get_contents($psi_url);
	if ($res_psi === false) {
		echo "PSI Error.n";
		continue;
	}

	$data_psi = json_decode($res_psi, true);

	$score = ($data_psi['lighthouseResult']['categories']['performance']['score'] ?? 0) * 100;
	$fcp   = $data_psi['lighthouseResult']['audits']['first-contentful-paint']['displayValue'] ?? 'N/A';
	$lcp   = $data_psi['lighthouseResult']['audits']['largest-contentful-paint']['displayValue'] ?? 'N/A';

	// 4. Send rich notification to Slack
	$report_link = "https://pagespeed.web.dev/analysis?url=https://" . $primary_domain . "&strategy=mobile";
	
	$slack_msg = [
		"text" => "🚀 *Performance Report: $site_label*nURL: `https://$primary_domain` nn" .
			"• *Score:* `$score` n" .
			"• *FCP:* $fcp n" .
			"• *LCP:* $lcpnn" .
			"[ <$report_link|View Full Report> ]"
	];

	$ch = curl_init($slack_webhook_url);
	curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($slack_msg));
	curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
	curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
	curl_exec($ch);
	curl_close($ch);

	echo "Done.n";
}

echo "--- MONITORING COMPLETED ---n";

Kurz gesagt, dieser Code durchläuft die Elemente des Arrays $sites. Für jedes Element des Arrays holt er Core Web Vitals ab und sendet eine Nachricht an Slack.

Testen des Skripts

Du kannst dich per SSH mit deinem Container verbinden und dein PHP-Skript direkt im Terminal ausführen. So kannst du dein Skript schnell auf Fehler untersuchen und erhältst die Leistungsergebnisse in Echtzeit in Slack.

Navigiere in MyKinsta zu Websites > Seitenname. Scrolle runter zum Abschnitt Primärer SFTP/SSH-Benutzer und suche das Feld SSH-Terminalbefehl. Es sollte in etwa so aussehen:

ssh wordpress@host-name -p port-number

Kopiere den SSH-Terminalbefehl und füge ihn in das Terminal ein. Du wirst aufgefordert, das im gleichen Abschnitt angegebene Passwort einzugeben. Drücke die Eingabetaste und du bist mit deiner Containerumgebung verbunden.

SSH-Verbindung zu Kinsta
SSH-Verbindung zu Kinsta

Jetzt kannst du deinen Code testen. Navigiere in der Kommandozeile zu dem Ordner, in den du das Skript hochgeladen hast. In diesem Beispiel haben wir den Ordner public verwendet:

cd public

Verwende dann den folgenden Befehl, um das Skript auszuführen:

php performance-monitor.php

Das Skript gibt für jede Aktion, die es ausführt, eine Meldung aus. Wenn es fertig ist, solltest du eine Liste von Meldungen sehen, die der folgenden ähnelt:

--- STARTING FULL PERFORMANCE MONITORING ---
Found 5 sites to analyze.
Analyzing site1.kinsta.cloud... Done.
Analyzing site2.kinsta.cloud... Done.
Analyzing site3.kinsta.cloud... Done.
Analyzing example.com... Done.
Analyzing site5.kinsta.cloud... Done.
--- MONITORING COMPLETED ---

Wenn das PSI nicht rechtzeitig antwortet, geht das Skript zur nächsten Website weiter. In diesem Fall siehst du eine Meldung, die wie folgt aussieht:

--- STARTING FULL PERFORMANCE MONITORING ---
Found 5 sites to analyze.
Analyzing site1.kinsta.cloud... Done.
Analyzing site2.kinsta.cloud... Done.
Analyzing site3.kinsta.cloud... Done.
Analyzing example.com... PSI Error.
Analyzing site5.kinsta.cloud... Done.
--- MONITORING COMPLETED ---

Während das Skript die Antworten von Google PSI verarbeitet, sendet es eine Nachricht an deinen Slack-Kanal. Für jede Website, die erfolgreich von PSI analysiert wurde, solltest du eine Slack-Nachricht sehen, die in etwa wie folgt aussieht:

Automatisierter Leistungsbericht auf Slack
Automatisierter Leistungsbericht auf Slack

Großartig! Du hast gerade dein automatisiertes Überwachungssystem erstellt.

Jetzt möchtest du es vielleicht an deine speziellen Bedürfnisse anpassen. Wenn du zum Beispiel Hunderte von Kundenseiten verwaltest, könnte es ineffizient sein, für jeder Seite eine Slack-Nachricht zu versenden.

Du könntest jedoch eine Bedingung einrichten, die die Gesamtbewertung der Website prüft und nur dann eine Nachricht an den Slack-Kanal sendet, wenn der von der PSI-API zurückgegebene Wert unter einem bestimmten Schwellenwert liegt (z. B. 90). Mit dem folgenden Code wäre das kein Problem:

$threshold = 90;

// 4. Send rich notification to Slack
// The alert is triggered only if the current score is strictly lower than our limit.
if ($score < $threshold) {
	echo "Score below threshold. Sending Slack alert... ";

	$report_link = "https://pagespeed.web.dev/analysis?url=https://" . $primary_domain . "&strategy=mobile";

	// Prepare the Slack message
	$slack_msg = [
		"text" => "⚠️ *Performance Alert: $site_label*nThe site score has dropped below the threshold of *$threshold*!nn" .
			"• *Score:* `$score` n" .
			"• *FCP:* $fcp n" .
			"• *LCP:* $lcpnn" .
			"[ <$report_link|View Full Audit Report> ]"
	];

	// Execute the CURL request to the Slack Webhook
	$ch = curl_init($slack_webhook_url);
	curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($slack_msg));
	curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
	curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
	curl_exec($ch);
	curl_close($ch);

	echo "Done.n";
} else {
	echo "Score is optimal ($score). No alert sent.n";
}

Aktualisiere dein Skript, speichere die Datei und lade sie erneut hoch. Verbinde dich dann per SSH mit dem Server, navigiere zu dem entsprechenden Ordner und führe den folgenden Befehl erneut aus:

php performance-monitor.php

Wenn du einen anderen Namen für dein Skript gewählt hast, ändere den Befehl entsprechend.

Im Terminal sollte nun eine Reihe von Meldungen ähnlich der folgenden angezeigt werden:

--- STARTING FULL PERFORMANCE MONITORING ---
Found 5 sites to analyze.
Analyzing site1.kinsta.cloud... Score is optimal (100). No alert sent.
Analyzing site2.kinsta.cloud... Score is optimal (95). No alert sent.
Analyzing site3.kinsta.cloud... Score is optimal (100). No alert sent.
Analyzing example.com... Score below threshold. Sending Slack alert... Done.
Analyzing site5.kinsta.cloud... Score below threshold. Sending Slack alert... Done.
--- MONITORING COMPLETED ---

In Slack erhältst du eine Nachricht für jede Website, deren Gesamtpunktzahl unter dem Schwellenwert von 90 liegt.

Ein automatischer Leistungsalarm in Slack
Ein automatischer Leistungsalarm in Slack

Das ist doch toll, oder? Aber du kannst den Prozess noch weiter optimieren. Würdest du nicht gerne noch mehr Zeit sparen, indem du das Skript automatisch in bestimmten Abständen ausführst, ohne auf dein Kommandozeilentool zugreifen zu müssen?

Ja, du hast es erraten. Du brauchst einen Cron-Job.

Automatisiere den Prozess mit einem Cron-Job

Es gibt mehrere Möglichkeiten, einen Cron-Job auf Kinsta einzurichten. Obwohl du das über WordPress machen kannst, können Kinsta-Nutzer/innen jedem Website-Container Server-Cron-Jobs hinzufügen.

Um einen Cron-Job auf Kinsta einzurichten, erstellst du einen Cron-Befehl und fügst ihn über SSH zur crontab-Datei deines Containers hinzu.

Du könntest zum Beispiel einen Befehl wie den folgenden verwenden:

0 10 * * * /usr/bin/php /www/yoursite_123/public/your-script.php >> /www/yoursite_123/performance_monitor.log 2>&1

Das macht dieser Befehl:

  • 0 10 * * * stellt das Skript so ein, dass es jeden Tag um 10 Uhr morgens ausgeführt wird.
  • /usr/bin/php ist der absolute Pfad des PHP-Interpreters auf dem Server.
  • /www/yoursite_123/public/your-script.php ist der absolute Pfad des Skripts. Achte darauf, den Pfad und den tatsächlichen Namen deines Skripts auf dem Server zu überprüfen.
  • Der Operator >> (append redirection) hängt neue Daten an das Ende der angegebenen Datei an.
  • /www/yoursite_123/performance_monitor.log gibt die Datei an, in der der gesamte vom Skript gedruckte Text gespeichert werden soll.
  • Der Befehl 2>&1 weist den Server an, Fehler in dieselbe Datei zu leiten.

Wir werden hier nicht näher auf die Cron-Befehle eingehen. Du kannst dich auf die Dokumentation von The Open Group beziehen oder ein Crontab-Tool wie Crontab Generator oder Cronitor verwenden.

Nachdem du deinen Cron-Befehl erstellt hast, musst du ihn zu deinem Website-Container hinzufügen. Du kannst entweder unser Support-Team bitten, dies für dich zu tun, oder es selbst per SSH erledigen. Wenn du dich für Letzteres entscheidest, gibst du zunächst den folgenden Befehl ein:

crontab -e

Du wirst aufgefordert, einen Editor auszuwählen. Wähle „nano“, wenn du dir nicht sicher bist.

Füge im Editor deinen Befehl am Ende der Datei ein. Speichere die Datei und kehre zur Befehlszeile zurück. Du solltest dann eine Meldung sehen, die bestätigt, dass deine Änderungen erfolgreich abgeschlossen wurden.

crontab installing new crontab

Das war’s schon. Das Skript wird nun in bestimmten Intervallen ausgeführt und sendet eine Nachricht an den Slack-Kanal deiner Wahl mit den angeforderten Metriken für deine Kundenstandorte, die eine schlechte Leistung aufweisen.

Was kannst du noch mit der Kinsta-API automatisieren?

Das in diesem Artikel vorgestellte Skript lässt sich anpassen und weiter ausbauen. Du könntest zum Beispiel andere Dienste wie Trello oder Asana integrieren, Daten exportieren oder regelmäßige E-Mail-Benachrichtigungen an deine Kunden senden.

Die Automatisierung deiner Leistungskontrollen auf den Websites deiner Kunden ist nur der Anfang. Durch die Integration der Kinsta-API in die täglichen Tools deines Teams kannst du die Abläufe in deiner Agentur verändern, indem du die manuelle Verwaltung und Wartung der Websites überflüssig machst, die Effizienz erhöhst und die Betriebskosten senkst. Außerdem verbesserst du die Servicequalität, verkürzt die Lieferzeiten und sorgst für das bestmögliche Erlebnis für deine Kunden.

Mit der Kinsta-API kannst du verschiedene Aufgaben automatisieren, z. B. das Erstellen von Staging-Umgebungen, das selektive Übertragen von Änderungen aus dem Staging in die Produktion, das Abrufen von Fehlerprotokollen, das Leeren des Website-Caches, die Verwaltung von Backups und vieles mehr. Diese Funktionen machen die Verwaltung von WordPress-Websites schnell und einfach und ermöglichen es dir, mit Zuversicht zu skalieren.

Bist du bereit, deine Agentur auf die nächste Stufe zu heben? Erkundige dich nach unseren Plänen oder kontaktiere unser Vertriebsteam, um deine speziellen Anforderungen zu besprechen.

Viel Spaß beim Skalieren!

Carlo Daniele Kinsta

Carlo ist ein leidenschaftlicher Liebhaber von Webdesign und Frontend-Entwicklung. Er beschäftigt sich seit über 10 Jahren mit WordPress, auch in Zusammenarbeit mit italienischen und europäischen Universitäten und Bildungseinrichtungen. Er hat Dutzende von Artikeln und Leitfäden über WordPress geschrieben, die sowohl auf italienischen und internationalen Websites als auch in gedruckten Magazinen veröffentlicht wurden. Du kannst Carlo auf X und LinkedIn finden.