CWA Logo

Welcome to
the CWA

The power of a
predictable data structure

With the rise in decoupled websites and the power of front-end frameworks, we began to think about a data structure that would fit for every website; what did every website need?

We didn't want to have to re-make common functionality for each website every time, and if we had a predictable data structure, it would be possible to have a powerful website builder and advanced functionality, while enabling a developer to create any website with complete flexibility.

Decoupled web apps

Decoupled/headless web apps are data driven. This opens up a world of possibilities - data can be shared between other web services, create API abstraction layers, and so much more.

Low-code, great DX

Easily use abstract classes, traits, and PHP annotations for the API. The front-end module builds on top of a UI layer and has ready-to-use components and powerful composables to get you up and running quickly.

Convention over configuration

Using a pre-defined directory and file structure allows the CWA Nuxt module to get you up and running fast. You can also add custom configuration to improve the user experience.

Free & Open-Source

The CWA is free, open-source and MIT licenced. Everyone can access, audit, contribute and explore the code and documentation.

Love writing content
draft, refine, publish

Making updates to a website requires time and thought. With publishable components, drafts are created when you make changes and ready to publish when signed off.

Easy to configure
Just 2 lines of code - an annotation and a trait and your component is enabled for advanced publishable features.
Add state-specific validation
Use pre-defined validation groups to apply validation specific to the component state. In the example, the Title resource cannot have a blank title property when it is in a published state.
api/src/Entity/Title.php
<?php
...

#[Silverback\Publishable] #[ApiResource(mercure: true)]
#[Orm\Entity]
class Title extends AbstractComponent
{
  use PublishableTrait;
  #[Assert\NotBlank(groups: ['Title:published'])]   #[Orm\Column(type: 'text', nullable: true)]
  public ?string $title = null;
}

Prefer trusting
the web designers

Unlike other website builders, we don't believe website admins should have unlimited creative freedom.

Components used as intended
As a developer, you can easily specify which components can be added to which component groups.
Pre-configure styles
Designers and developers define the styles that a website admin can select from. This keeps your client on brand, no matter who updates the site.
Build components your way
Web designers and developers are provided with helpers. We do not impose any HTML structure of stylistic choices. Build, extend and express as you want.
Leave it to the professionals

Feel united with
real-time updates

We integrate with Mercure to push real-time updates from the API to website users.

Publish changes immediately
When you make a change, affected users get an immediate notification so they can stay up to date.
Collaborate on changes
Multiple website admins can work together on changes without external tools.
Authenticated updates
With authentication built in by default, the browser will only receive updates for relevant resources. Website visitors will not be exposed to draft component updates.
Stay In Sync with the CWA

Impress & convert
with fast websites

We have optimised the system for the fastest response times and an enhanced user experience.

Simple, small API responses
Each API request returns a small amount of data and a single resource instead of complex and deeply nested data.
UX: Speedy first impressions
The page UI updates as soon as the primary resources are loaded from the API or local cache for the fastest FCP (First Contentful Paint) possible. The CWA only loads resources that are required for each page, and reuses resources from a local cache if they exist on multiple pages.
Caching and Preload Hints
We leverage a smart static cache layer, which is only cleared when resources change. We also leverage Vulcain with preload hints to improve response times.
CWA is built for Speed - Plane breaking sound barrier

Freedom to choose
your own (file) path

We have built in easily configurable file uploads and a file storage abstraction layer with Flysystem.

Easy to configure
Similar to publishable components, with a little config and annotations, you'll have file uploads setup in no time.
Pre-configured file-systems
Flysystem has several file storage systems already built in, such as Google Cloud, AWS S3, Azure Blob and Local Storage.
Build your own file storage adapter
Documentation to configure your own file storage is readily available and there are more third-party file storage providers available.

Easy & flexible to
build & deploy

When it comes to deploying your application, we know designing the tech stack can be difficult. We have done all the heavy lifting.

Dockerized
We have built the tech stack into Docker containers and Docker Compose configurations so it is vendor agnostic and can be easily deployed.
Kubernetes & Helm
Deploy to your own Kubernetes cluster and take advantage of HPA and VPA with easy to customise templates using our included Helm chart.
Bash scripts for CI
Although we have a vendor specific GitLab configuration, it is easy to create your own for other CI providers as we have created a bash script with functions to carry out the common tasks.
Optimised tech stack
We use a Caddy server with FrankenPHP in our tech stack for optimal performance. We noted a 95% reduced latency vs a previous FPM configuration when under heavy loads. The Caddy modules for Mercure, Vulcain and Souin are also pre-configured.

Technical FAQs

Some common technical questions we have about the CWA

With a background in PHP and Symfony, and the API Platform framework being well maintained by great developers, we decided to use these advanced features and give stability to the project as we knew development of this concept could take some time.

We found VueJS and Nuxt to be incredibly fun frameworks for the front-end and well maintained. In both instances we wanted to create a system that was built on the shoulders of giants; we didn't want to re-invent the wheel.

The strong vibrant community behind these frameworks gives confidence and re-assurance your project will be secure and stable going on into the future.

Each individual resource is loaded with a separate request. It results in a lot of HTTP requests, however each part has very small, and most importantly, cacheable, chunks of data.

We only need to load in the data that is required for each individual page which can result in incredibly fast load times.

Contact us at hello@cwa.rocks or raise issues in our GitHub repositories and we will be happy to help.

If you need more personal technical help, Silverback Web Apps will be able to assist.