WordCamp Poland 2023 - Gliwice report and summary

WordCamp Poland 2023 in Gliwice proved once again why this conference remains the focal point for digital craftsmanship across Central Europe. Held in Silesia’s recognized innovation hub, colloquially known as Poland’s technological valley, the three-day gathering united over 200 senior developers, agency founders, designers, and infrastructure architects.

The conference offered an exceptional blend of hands-on open-source contributions, forward-looking architectural debates, and rigorous business frameworks. As WordPress continues to power over 40 percent of the web, the discussions in Gliwice centered on elevating software standards: adopting modern static frontend tools, decoupling content repositories, and enforcing strict code quality in production.

If your enterprise requires senior technical direction or you are planning a complex migration, explore our dedicated services as a WordPress developer at WPPoland.

#1. Contributor Day: Strengthening open source foundations

The conference opened on Friday, May 12, with Contributor Day. Rather than focusing on passive listening, Contributor Day gathers developers into working groups dedicated to advancing the WordPress open-source ecosystem.

Participants collaborated across multiple core tables:

• Core & Gutenberg: Triaging open Trac tickets, reviewing Gutenberg pull requests on GitHub, and writing automated unit tests for block serialization.
• Polyglots: Translating core packages, popular plugins, and administrative strings into Polish and other regional languages.
• Documentation & Training: Updating official developer documentation, revising code references, and formulating tutorials for Full Site Editing (FSE).
• Community: Mentoring new organizers and planning regional WordUp meetups across Poland.

Contributing directly to the core software establishes a vital feedback loop between agency engineers solving enterprise edge cases and the core committers maintaining the platform runtime.

#2. Business strategy and agency evolution

The Saturday program addressed the commercial realities of operating a WordPress engineering agency in a maturing global economy. Speakers focused on building resilient business models that transcend fragile hourly billing:

#From service firm to productized retainers (Tomasz Karwatka)

Tomasz Karwatka, co-founder of Divante and Catch The Tornado, delivered an incisive analysis of the agency lifecycle. He detailed the common pitfalls of linear service scaling, where revenue is bound strictly to headcount and billable hours.

The strategic imperative for agencies is productization: turning custom bespoke builds into repeatable SaaS tools, proprietary starter boilerplate frameworks, and value-priced monthly maintenance retainers. This shift provides predictable cash flow and allows engineering teams to invest in continuous internal tooling.

#Implementing OKRs in software delivery (Łukasz Wilczak)

Łukasz Wilczak provided a practical case study on deploying the OKR (Objectives and Key Results) methodology inside development teams. In traditional web agencies, project delays and scope creep frequently damage client relationships. By establishing quarterly qualitative Objectives tied to measurable Key Results (such as achieving sub-1.2s Largest Contentful Paint across all client releases and automating 90 percent of deployment sanity checks), agencies maintain technical discipline and align engineering incentives with customer satisfaction.

#3. Technical deep dive: Headless WordPress with Astro (Maciek Palmowski)

One of the most technically impactful presentations was delivered by Maciek Palmowski, who showcased the power of decoupling WordPress from its traditional PHP frontend by using Astro as a high-performance static site generator (SSG).

DECOUPLED HEADLESS WORDPRESS ARCHITECTURE:
+-------------------------------+      REST API / GraphQL      +-------------------------------+
|     WordPress Backend         | ---------------------------> |     Astro Static Generator    |
| (wp-admin, editorial workflow,|       JSON Data Payloads     | (Zero client JS by default,   |
|  custom post types, ACF Pro)  |                              |  component islands, SSG HTML) |
+-------------------------------+                              +-------------------------------+
                |                                                              |
                v                                                              v
+-------------------------------+                              +-------------------------------+
| MySQL / MariaDB Database      |                              | Edge CDN (Cloudflare / Pages) |
| (Protected behind firewall,   |                              | (Instant sub-100ms TTFB,      |
|  inaccessible to public web)  |                              |  impenetrable attack surface) |
+-------------------------------+                              +-------------------------------+

#Why headless architectures eliminate legacy frontend bottlenecks

In a classic WordPress setup, every incoming HTTP request requires the PHP engine to bootstrap plugins, execute database queries against wp_posts and wp_postmeta, parse template hierarchies, and assemble the final HTML response. Under heavy traffic spikes, server CPU quickly saturates.

By pairing WordPress with Astro:

1. Zero client-side JavaScript by default: Astro renders clean, semantic HTML on the server during the build phase. Unlike heavy JavaScript Single Page Application (SPA) frameworks like Next.js or Nuxt, Astro ships zero runtime JavaScript unless explicitly instructed via client directives (client:idle, client:visible).
2. Superior Core Web Vitals: TTFB (Time to First Byte) drops from 600-1200ms down to 30-50ms when delivered via edge networks like Cloudflare Pages. First Contentful Paint (FCP) and Cumulative Layout Shift (CLS) achieve perfect Lighthouse scores.
3. Hardened security posture: The WordPress administrative instance can be hosted on an isolated internal subdomain behind strict zero-trust authentication. The public never interacts with the PHP runtime or MySQL database, completely neutralizing common attack vectors.

#Production code sample: Astro static route consuming WP REST API

---
// src/pages/blog/[slug].astro
export async function getStaticPaths() {
  const response = await fetch("https://cms.example.com/wp-json/wp/v2/posts?_embed&per_page=100");
  const posts = await response.json();

  return posts.map((post) => ({
    params: { slug: post.slug },
    props: { post },
  }));
}

const { post } = Astro.props;
const featuredImage = post._embedded?.['wp:featuredmedia']?.[0]?.source_url;
---

<article class="prose max-w-3xl mx-auto py-12">
  <h1>{post.title.rendered}</h1>
  {featuredImage && <img src={featuredImage} alt={post.title.rendered} loading="eager" />}
  <div set:html={post.content.rendered} />
</article>

#4. Advanced WP-CLI automation (Marcin Krzemiński workshop)

During the hands-on technical workshop, Marcin Krzemiński demonstrated advanced command-line techniques using WP-CLI. For enterprise teams managing dozens of high-traffic environments, performing updates, migrations, and database replacements through a web browser is unacceptable.

#Safe database search and replace with serialised data integrity

A common disaster in manual SQL search-and-replace scripts is corrupting serialized PHP arrays in the wp_options and wp_postmeta tables. When string lengths change without updating the length metadata (e.g. s:21:"https://staging.local" changed to s:19:"https://example.com"), PHP fails to deserialize the object, resulting in broken widgets and lost theme settings.

WP-CLI deserializes, replaces, recalculates string byte lengths, and re-serializes the data safely:

# Step 1: Execute a dry-run to preview affected tables and matching rows
wp search-replace "https://staging.example.com" "https://example.com" \
  --all-tables \
  --dry-run \
  --precise

# Step 2: Run the actual database replacement with an automated export backup
wp db export pre-migration-backup.sql
wp search-replace "https://staging.example.com" "https://example.com" \
  --all-tables \
  --precise \
  --recurse-objects

#Scripting automated plugin and core maintenance

# Verify file checksums against official WordPress.org releases
wp core verify-checksums
wp plugin verify-checksums --all

# Update plugins while ignoring third-party proprietary vendor packages
wp plugin update $(wp plugin list --update=available --field=name)

# Flush object cache and regenerate rewrite rules
wp cache flush
wp rewrite flush --hard

#5. Modern plugin engineering: Dependency injection over global hooks

Another standout technical session focused on applying clean architecture principles to WordPress plugin development. In traditional WordPress plugins, code often devolves into procedural spaghetti: hundreds of functions registered across functions.php, scattered global variables (global $wpdb), and tightly coupled database calls.

By implementing lightweight Dependency Injection (DI) containers conforming to the PSR-11 standard, engineering teams achieve testable, modular, and maintainable software.

<?php
declare(strict_types=1);

namespace WPPoland\Plugin;

interface CacheInterface {
    public function get(string $key): mixed;
    public function set(string $key, mixed $value, int $ttl = 3600): bool;
}

final class RedisCacheService implements CacheInterface {
    public function get(string $key): mixed {
        return wp_cache_get($key, 'wppoland_group');
    }

    public function set(string $key, mixed $value, int $ttl = 3600): bool {
        return wp_cache_set($key, $value, 'wppoland_group', $ttl);
    }
}

final class CustomerReportManager {
    public function __construct(
        private readonly CacheInterface $cache,
        private readonly \wpdb $db
    ) {}

    public function generateReport(int $customerId): array {
        $cacheKey = "customer_report_{$customerId}";
        $cached = $this->cache->get($cacheKey);

        if ($cached !== false) {
            return $cached;
        }

        $query = $this->db->prepare(
            "SELECT * FROM {$this->db->prefix}customer_orders WHERE customer_id = %d",
            $customerId
        );
        $data = $this->db->get_results($query, ARRAY_A);

        $this->cache->set($cacheKey, $data, 1800);
        return $data;
    }
}

This decoupled pattern allows developers to mock the CacheInterface in automated PHPUnit and Pest tests without needing a live WordPress database connection, reducing test suite execution times from minutes to milliseconds.

#6. Infrastructure lessons from the sponsor floor

Direct consultations with engineers representing managed hosting providers and cloud infrastructure firms in the sponsor exhibition hall yielded critical insights into scaling bottlenecks:

Engineers emphasized that calling wp-cron.php on every page visit introduces unpredictable latency spikes for real users. The recommended enterprise standard is disabling native web cron via define('DISABLE_WP_CRON', true); and scheduling a system-level cron job to trigger WP-CLI every five minutes.

#7. Conclusion

WordCamp Poland 2023 in Gliwice showcased an engineering community operating at the top of its game. From the open-source collaboration on Contributor Day to advanced discussions on Headless Astro architectures, WP-CLI automation, and dependency injection, the event provided clear proof that WordPress is evolving rapidly into a modern, enterprise-grade application platform.

Attending in-person conferences provides software teams with the technical perspective and personal relationships necessary to build durable, scalable web systems.

If your business is planning a migration to Headless WordPress, needs Core Web Vitals remediation, or requires enterprise development expertise, learn more about our specialized WordPress development services.