Custom Concrete CMS Package Development

A Concrete CMS project grows. Blocks multiply, themes are edited live, and moving functionality between installations becomes a manual copy-paste. Typical scenario: a client orders a "product card" block, then another, then a theme. Six months later — six blocks, two themes, three custom attributes — and none of them transfer to a new site without a dance with a tambourine. The solution is pack everything into one custom package.

Our engineers with 5+ years of experience developing for Concrete CMS help turn scattered work into a single, reusable module. During this time we have implemented over 30 packages for corporate clients — from simple block sets to full-featured modules with REST API, Doctrine entities, and background tasks. Savings on each deployment reach 90% time, reducing total cost of ownership up to 40%. Contact us to discuss your project — consultation is provided within a day.

Savings When Using a Custom Package

Manual installation of each component separately leads to code duplication, errors in database schema updates, and uncontrolled versions. A custom package solves these problems. One controller.php file automatically installs blocks, themes, attributes, page types, and Cron tasks. Compare: manual installation on a new site takes 2 to 5 hours of per-component setup. A package installs in 5 minutes. Time savings — 10–20 times on each deployment.

How a Custom Package Is Structured in Concrete CMS?

A package is just a folder with a clear structure. The main file is controller.php, which describes dependencies and automatically installs all components.

packages/my-package/ controller.php blocks/ feature-card/ controller.php db.xml add.php edit.php view.php themes/ my-theme/ attributes/ color_picker/ controller.php single_pages/ dashboard/my_package/settings.php elements/my_package/settings_form.php jobs/sync_products.php src/Entity/Order.php src/Repository/OrderRepository.php src/Service/OrderService.php db.xml 

Key Package Components

• controller.php — registers the package, installs blocks, page types, attributes, and Dashboard pages.
• Blocks — custom interface elements (feature-card, team-member).
• Themes — global site design.
• Attributes — custom fields for pages and blocks.
• Single pages — settings pages in the Dashboard.
• Cron Jobs — background tasks (synchronization, email sending).
• Doctrine entities — working with tables via ORM.
• REST API — custom endpoints for integrations.

Package Controller

The heart of the package is the Controller class extending Concrete\Core\Package\Package. It describes the installation, upgrade, and removal of components.

<?php namespace Concrete\Package\MyPackage; use Concrete\Core\Package\Package; use Concrete\Core\Page\Single as SinglePage; use Concrete\Core\Block\BlockType\BlockType; use Concrete\Core\Page\Type\Type as PageType; use Concrete\Core\Attribute\Type as AttributeType; use Concrete\Core\Job\Job; defined('C5_EXECUTE') or die('Access Denied.'); class Controller extends Package { protected string $pkgHandle = 'my-package'; protected string $appVersionRequired = '9.0.0'; protected string $pkgVersion = '2.1.0'; public function getPackageName(): string { return t('My Package'); } public function getPackageDescription(): string { return t('Full functional package for corporate site'); } public function on_start(): void { $this->app->make(\Concrete\Package\MyPackage\Routing\RouteRegistrar::class)->register(); $this->app->make('Concrete\Core\Foundation\Service\ProviderList') ->registerProvider(\Concrete\Package\MyPackage\Provider\ServiceProvider::class); } public function install(): void { $pkg = parent::install(); $this->installOrUpgrade($pkg); } public function upgrade(): void { parent::upgrade(); $pkg = $this->getPackageEntity(); $this->installOrUpgrade($pkg); } private function installOrUpgrade(\Concrete\Core\Entity\Package $pkg): void { $this->installBlock('feature-card', $pkg); $this->installBlock('team-member', $pkg); $this->installBlock('testimonial', $pkg); $this->installPageType('service-detail', 'Service Detail', $pkg); $this->installPageType('team-member', 'Team Member', $pkg); $this->installPageAttribute('hero_image', 'image', 'Hero Image', $pkg); $this->installPageAttribute('intro_text', 'text', 'Intro Text', $pkg); $this->installPageAttribute('meta_description', 'textarea', 'Meta Description', $pkg); $this->installPageAttribute('show_in_nav', 'boolean', 'Show in Navigation', $pkg); $sp = SinglePage::add('/dashboard/my_package', $pkg); if ($sp) $sp->update(['cName' => 'My Package', 'cDescription' => 'Settings']); $sp = SinglePage::add('/dashboard/my_package/settings', $pkg); if ($sp) $sp->update(['cName' => 'Settings']); Job::installByPackage('sync_products', $pkg); } private function installBlock(string $handle, $pkg): void { if (!BlockType::getByHandle($handle)) { BlockType::installBlockTypeFromPackage($handle, $pkg); } } private function installPageType(string $handle, string $name, $pkg): void { if (!PageType::getByHandle($handle)) { PageType::add(['ptHandle' => $handle, 'ptName' => $name, 'ptIsFrequentlyAdded' => 0, 'ptLaunchInComposer' => 1], $pkg); } } private function installPageAttribute(string $handle, string $type, string $name, $pkg): void { $at = AttributeType::getByHandle($type); $ak = \Concrete\Core\Attribute\Key\CollectionKey::getByHandle($handle); if (!$ak) { \Concrete\Core\Attribute\Key\CollectionKey::add($at, ['akHandle' => $handle, 'akName' => $name], $pkg); } } public function uninstall(): void { parent::uninstall(); $db = $this->app->make('database')->connection(); $db->executeStatement('DROP TABLE IF EXISTS MyPackageOrders'); } } 

Comparison: Custom Package vs Manual Installation

A custom package speeds up deployment 3–5 times and completely eliminates manual assembly errors. We guarantee compatibility with latest Concrete CMS versions.

Package Development Process

1. Requirements analysis — determine package composition (blocks, themes, attributes, entities, API).
2. Architecture design — database schema, class structure, routes.
3. Implementation — writing controller, blocks, entities, tasks.
4. Testing — checking installation, upgrade, removal on a test site.
5. Documentation — instructions, API description, examples.
6. Deployment — packaging, delivery to client.

What's Included in Package Development

• Source code in a Git repository.
• Documentation: installation, setup, administration.
• Team training (1–2 hours).
• 6-month warranty on support and bug fixes.
• Free upgrade when a new CMS version is released (during warranty period).

What Typical Errors Does a Package Solve?

Consider a real case. A client manually developed 6 blocks, but on a new site the blocks didn't display due to missing dependencies in db.xml. It took 3 days to reinstall each block and fix migrations. With a package, we solved it in 2 hours: described all blocks in the controller, added automatic table creation via db.xml, and tested installation on a clean core. No more transfer errors.

When to Order a Custom Package?

A package is justified if you plan to use the same functionality on multiple sites, want to standardize development, or need guaranteed component portability. If the project is one-off and doesn't require extension, manual installation may suffice. But in most corporate scenarios, the package pays for itself by the second deployment.

Package Development Timeline

Read more about Concrete CMS on Wikipedia.

Order a custom package development — get a consultation within a day. Contact us to discuss your project.