WordPress Community Insights You May Not Know About

WordPress Community Insights You May Not Know - Plesk

Each year, seasoned WordPress developers, agency owners, WebPro experts and beginner users come together at WordCamps. From around the world, we connect, learn, and celebrate all things WordPress. WordCamps have grown from the one held by Matt Mullenweg in 2006, San Francisco – to hundreds all over the globe. Each with their own flavour, speakers, sessions, and communities. It’s only natural that we want to get more WordPress Community Insights.

As we create many WordPress-related products, we’re proudly involved in the community that makes WordPress and make regular appearances at WordCamps. We support WordCamps both with sponsorship and by showing up with a booth, speakers, games, special offers, raffles, and interviews. In November 2019, we attended WordCamp US and joined the thousands of other WP enthusiasts and experts. Celebrating and evolving the thriving WordPress ecosystem, hosting educational and engaging games and raffles with special prizes.

In exchange for the grand prize (that any techy would love), we took the opportunity to gather answers to a few burning questions for the WP community. We collated the responses from over one hundred respondents in the infographic you see below. Now we’re going to dive into these findings in a bit more detail and discuss a few patterns and trends we noticed.

Community Insights from WordCamp US 2019

WordPress is such a diverse and flexible platform that it’s used daily by a million different people in a million different ways. To be exact, there’s over 75 million people using WordPress in over 50 different languages. Powering over 172 million websites (around a third of the entire web). And those numbers are still growing.

So who are the WordPress Community?

From our survey of WordCamp attendees, we discovered that, as you would expect, most of them are developers — nearly half at 42%. The rest are a diverse bunch of bloggers, graphic designers, agency owners, marketers, SEOs, freelancers, security researchers, software developers. There are also prospective dev students or small business owners who are newbies to the WordPress world.

As you can see, there’s a real mix of people using WordPress for everything. From personal projects and their own career development to running businesses and supporting client projects. This is reflected in the reasons as to why people were attending WordCamp US.

Most of the respondents were at the event for both personal and professional reasons. With overall the biggest attraction being the opportunity to network, make connections, and simply have interesting conversations with like-minded people.

Of course, some people were there because they were running a session or because they simply wanted the free swag. But even so, they may have been meeting up with someone they met online or were otherwise benefiting from the strong WP community. Similarly, when we asked what they hope to take away from the weekend, respondents mostly mentioned making new friends, contacts and connections.

Other top takeaways included new knowledge/learning, feedback, contributing to the community and learning new solutions for current WP challenges. Many also want to improve accessibility of websites, or get a clearer idea of hosting options and new features out there. And, of course, grab some swag while they’re at it.

How The Community Uses WordPress

When you get a bunch of WP aficionados together in the same place, you can’t not ask them about their experiences with WordPress and the tools they’re currently using. Starting at the top with hosting options, over a third of people (39%) preferred Managed WordPress Hosting, with Cloud and Shared Hosting following at 17%.

In line with these results is what they voted as the most important factors when working with WordPress. Speed and performance took the crown with nearly two-thirds of the vote. While 45% were happy enough to have WordPress work well. However, 44% also wanted stability, and 36% were looking for a user-friendly design.

With over 50,000 plugins available, the WordPress plugins marketplace is booming. Many look to WordCamp for insights into plugins to announce development of their latest ground-breaking product. Maybe even to improve the efficiency of their sites, or simply discover what’s out there.

Interestingly, SEO plugins like Yoast are the most-used WordPress tools, with 55% of respondents using them over others. Second were analytics tools with 37%, security tools at 31%, and page builders, CSS and email marketing plugins coming up the rear.

This shows a clear focus of WP users to quantify and boost their site performance in search engine results pages (SERPs) as much as possible.

Doing Our Bit For The WordPress Community

To finish off the survey, we asked the WordCamp US attendees a few more questions, including if they had any WP-related goals, and if so, what they were. The results revealed that WordCamps have a feel of being about socialising and educating people. However, they’re also pivotal for those serious about pushing their business goals forward.

Some of the respondents’ top WordPress-related goals were:

  • making their products known to the world
  • growing their WordPress client base
  • becoming web developers
  • blogging more consistently
  • building non-profit websites
  • Building awesome sites in general
  • teaching more
  • Increasing their traffic and scaling
  • Getting all the clients and dominating the world

To help fellow members of the WordPress community to achieve these goals, we’ve built a variety of WordPress tools like the Plesk WordPress Toolkit. The WP Toolkit is a single interface for easily installing, configuring, and managing WordPress, jam-packed with features.

We asked the community if they thought the Plesk Toolkit would benefit their work. Nearly half of respondents chose “yes”, with just under a quarter choosing “I think so.” A few of the things that are holding people back included the price. Some were also not sure if it would integrate well. And a few would not go for it, simply because they don’t like change.

Looking Ahead to The Next WordCamp

Go for the speakers, the opportunities, the insights, the lego prizes, swag – or all of the above. Attending a WordCamp is a great way to meet awesome people and stay in touch with everything WordPress.

There has been over 700 WordCamps in 70 cities around the world to date. We plan to attend more in 2020 to continue supporting the WP community and development of the incredible open source platform. Starting with WordCamp Asia in February. To find a WordCamp near you, or even set up your own, visit WordCamp central.

Will you be attending WordCamp Asia in February 2020? What content would you like to see us cover from the event?

Automated testing for your WordPress – Steve Grunwell at WCUS

Automated testing for your WordPress

Steve Grunwell is a Senior Software Engineer at Liquid Web who works on Managed WordPress platforms, specializing in WP and web app development. He says WordPress is a tightly-coupled system with a history of ideas, decisions and technical shifts that can mean consequences for even simpler tasks. However, you can ensure software is released regularly with low regression risk with automated testing.

Steve Grunwell WCUS 2019 - Plesk

Building WordPress plugins with tests can seem challenging, however there are tools to set up a test harness within an existing codebase with ease. In his WCUS talk, Steve talked about the fundamentals of automated testing, particularly in regards to WordPress. Plus, how to start testing plugins and themes using features from PHPUnit and the WordPress core testing framework. In order to finally build and release quality software.

About Automated Testing

Achieving continuous integration and delivery is the holy grail. We can start automated the entire process from writing code to production. Automated testing plays a vital part in letting us reduce time and chance of human error. It is easily reproducible and a gateway to CI/CD.

For WordPress automation, testing, staging, smart updates and more, check out our complete Plesk WordPress Toolkit.

Test Types

Unit Test – Tests the smallest possible unit of an app. It’s often a single function.

Integration Test – Takes all the unit tests and finds if they work together in the way we’re expecting.

E2E (end-to-end) – Tests the entire path through the organization.

automated testing pyramid - Steve Grunwell

They may cost more to test the higher up the pyramid you go but maybe they take even longer to run. You are after all in many cases making HTTP requests.

SUT (System Under Test)

This refers to the current system we’re trying to test. It can be a single method, a class, or a whole feature. What are we trying to accomplish with our test? And how do we get everything else out of the way so we can focus on that?

When it comes to WP, we do have to shift a little. As we said, it’s a very tightly-coupled system. So, it’s very hard to test single items in true isolation. But this doesn’t mean we can’t do this effectively. And this is what Steve talked about at WCUS 2019.

PHPUnit – Our testing toolbox

Steve talked about PHPUnit by first explaining its structure.

Test Suite – This is a collection of test classes.

Test Class– a collection of one or more test cases.

Test Case – A single scenario you’re going to test.

It’s going to be comprised of one or more assertions. Do things work the way that we expect? Here are a few scenarios that Steve Grunwell highlights.

Is it true or false?

assertTrue () $value ===true?

$this->assertTrue(true);

assertFalse () $value ===false?

$this->assertFalse(false);

Equality

assertEquals()  $expected == $actual?

$this->assertEquals($expected, $actual);

assertSame()  $expected == $actual?

$this->assertSame($expected, $actual);

Verifying contents of things

assertContains () Does $value contain $expected?

$this->assertContains('b', ['a', 'b', 'c']);

assertRegexp() Does $value match the given $regex?

$this->assertRegexp('/^Fo+/', 'Foo Bar');

Negative assertions

For every assertion, there is a positive and negative assertion.

assertEquals () $expected ==$actual?

assertNotEquals () $expected ==$actual?

 

assertContains () $expected ==$actual?

assertNotContains () $expected ==$actual?

 

assertCount () $expected ==$actual?

assertNotCount () $expected ==$actual?

 

assertArrayHasKey () $expected ==$actual?

assertNotArrayHasKey () $expected ==$actual?

 

Do we have at least one match? Everything comes down to true or false. The key to understanding assertions in our tests. Here is an example of a test report:

PHPUnit 7.5.1 by Sebastian Bergmann and contributors.

...............................................  47 / 511 ( 9%)

...............................................  94 / 511 ( 18%)

...................................SSSS........ 141 / 511 ( 27%)

............................................... 188 / 511 ( 36%)

............................................... 235 / 511 ( 45%)

............................................... 282 / 511 ( 55%)

............................................... 329 / 511 ( 64%)

............................................... 376 / 511 ( 73%)

............................................... 423 / 511 ( 82%)

............................................... 470 / 511 ( 91%)

.........................................       511 / 511 (100%)

 

Time: 1.13 minutes, Memory: 42.00MB

 

OK, but incomplete, skipped, or risky tests!

Tests: 511, Assertions: 1085, Skipped: 4.

 

PHPUnit 7.5.1 by Sebastian Bergmann and contributors.

 

.......F........                                 16/16 (100%)

 

Time: 7.15 seconds, Memory: 14.00MB

 

There was 1 failure:

 

1) Tests\CoffeeTest::test_get_good_coffee

Failed asserting that two strings are identical.

--- Expected

+++ Actual

@@ @@

-'great, well-balanced coffee'

+'Starbucks'

 

/my-plugin/tests/test-coffee.php:14

 

FAILURES!

Tests: 16, Assertions: 19, Failures: 1.

It ran through over 1K test in under a minute. If you were to do this manually it would take days instead of minutes. 

Test Doubles

As we test things, sometimes we want to get things out of the way in our code. This is where test doubles come into play. The general idea is to remove any variables in our code and give ourselves test versions to replace actual systems. Always returning known values and ensuring systems behave a certain way. When dealing with test doubles, a popular library for creating test doubles is Mockery.

public function test_handles_empty_order_list() {

    $api = Mockery::mock( Api::class )->makePartial();

    $api->shouldReceive( 'get_all_orders' )

        ->once()

        ->andReturn( [] );

    $this->assertEmpty( $api->get_recent_orders() );

}

There’s also the PHPUnit Markup assertions, powered by DOMDocument. Lets use DOMDocuments to make a DOM query.

function test_button_contains_active_state() {

    $output = some_function();

    $this->assertContainsSelector('.button.active', $output);

}

WP Core Test Suite

This is what WP core itself uses to ensure all the PHP in WP is behaving the way we expect it to. If we want to use the core test suite, you can run $ wp scaffold plugin-tests my-plugin to generate test scaffolding via WP-CLI. Get the test suite out of the box.

We want to make sure certain things happen before every test method. You don’t have to write it every time, only once.

We have the concept of groups where we run tests of a similar nature across suites and classes. I can just run the following code.

/**

 * @group Posts

 * @group PostMeta

 */

public function test_includes_private_posts()

{

    // ...

}

$ phpunit --group=Posts

This comes in handy when you have a large test suite and want to make sure related things aren’t going to break.

Data Providers

Often in our testing you can have the same test but different data. For this, we have a nice tool called data providers. You can run through them without having to paste the same method over and over again. So we specify a data provider for it. If you’re working with simple data types like strings and integers. You can choose to define just one method for example:

/**

 * @dataProvider my_data_provider()

 */

public function test_my_function( $expected, $value ) {

    $this->assertEquals( $expected, my_function( $value ) );

}

 

public function my_data_provider() {

    return [

        'Description of case 1' => ['foo', 'bar'],

        'Description of case 2' => ['bar', 'baz'],

    ];

}

/**

 * @testWith ["foo", "bar"]

 *           ["bar", "baz"]

 */

public function test_my_function( $expected, $value ) {

    $this->assertEquals( $expected, my_function( $value ) );

}

You can even generate dummy data with factories tests. You can generate users, posts and more – for testing purposes.

// Create the post and retrieve its ID.

$post_id = $this->factory->post->create();

 

// Create and retrieve the new post.

$post = $this->factory->post->create_and_get();

 

// Override default parameters.

$post = $this->factory->post->create_and_get( [

    'post_title'  => 'My Test Post',

    'post_author' => $author_id,

] );

 

// Create multiple instances.

$posts = $this->factory->post->create_many( 5, [

    'post_author' => $author_id,

] );

Checking for WP_ERRORS

Was the response an instance of WP_Error? Coming back to the search for truth – Is truth a WP_Error? As we write our code, there’s a pattern for how this should be arranged to set up the scenario.

public function test_function_can_return_wp_error() {

    $response = myplugin_function();

 

    $this->assertWPError($response);

}

Next we execute the code, and finally we make assertions around it – in other words, verify that things happened as you expected.

Testing Permissions

public function test_non_admins_cannot_clear_cache() {

    // Arrange

    $user_id = $this->factory->user->create( [

        'role' => 'author',

    ] );

 

    wp_set_current_user( $user_id );

 

    // Act

    $response = myplugin_clear_cache();

 

    // Assert

    $this->assertWPError($response);

    $this->assertSame(403, $response->get_error_code());

}

Registering a custom post type

public function test_book_cpt_is_registered() {

    myplugin_register_post_types();

 

    $post_type = get_post_type_object( 'book' );

 

    // Verify the post type is registered along with key properties.

    $this->assertNotNull( $post_type );

    $this->assertTrue( $post_type->public );

    $this->assertFalse( $post_type->hierarchical );

}

Testing Hooks

public function test_function_does_action() {

    myplugin_function();

 

    $this->assertSame( 1, did_action( 'myplugin_action' ) );

}

public function test_function_does_action() {

    $called = false;

 

    // Register a callback to validate arguments.

    add_action( 'myplugin_action', function () use (&$called) {

 

        // Only return true if validations passed.

        $called = true;

    } );

 

    myplugin_function();

 

    $this->assertTrue( $called );

}

Testing Output

public function test_shortcode_output() {

    ob_start();

    do_shortcode( '[recent-posts title="Latest Posts"]' );

    $output = ob_get_clean();

 

    $this->assertContains( '<h2>Latest Posts</h2>', $output );

}

public function test_shortcode_output() {

    $this->expectOutput( '<h2>Latest Posts</h2>' );

 

    do_shortcode( '[recent-posts title="Latest Posts"]' );

}

Stubbing HTTP Requests

add_filter( 'pre_http_request', function () {

    return [

        'headers'  => [],

        'body'     => '',

        'response' => [

            'code'    => 200,

            'message' => 'OK',

        ],

        'cookies'  => [],

        'filename' => '',

    ];

} );

Basic Automated Testing Workflow

Steve explains the basic idea behind TDD – test driven development.

  1. Write a (failing) test to describe the functionality/behavior. You’re describing how it should work. This can be called ‘red’ – there is a broken code.
  2. Write the code necessary to make the test pass. All we have to do is get the test to pass. This can be known as green – the code that works.
  3. Refactor, rinse, & repeat. Now we can go back and refine the code.

Automation is the way forward and one that strongly resonates with Plesk’s values and beliefs. You can find the slide deck from the talk here. Thanks Steve for sharing your expertise on automated testing!

Tools and Tricks to Manage Multisite and Control Your Network

Tools and Tricks to Manage Multisite and Control Your Network - Plesk at WCUS 2019

Matthew Rodela started out in IT consulting and has been building WP websites for about 10 years now. He acquired a theme called Website Builder for IT businesses. It came with tutorials on how to configure the theme and so on. He decided to turn it into more of a platform. Hence, after lots of trial and error, techsitebuilder.com was born. Turns out an automated Multisite was a better model for both his customers and his business.

“WordPress is a powerful platform that can really help organize and streamline website development.” 

However, Multisite can prove tricky to manage without the right tools and processes. That’s why Matthew chose to talk about plugins that can better help you manage your network. Plus the effective processes that can keep everything up-to-date, secure and backed up. Matthew’s lightning talk was not for developers specifically, but anyone who offers WordPress services to customers.

Providing your customers with the best WordPress solution

You may be used to the WordPress dashboard and how well it works. But oftentimes our clients are intimidated by it or don’t understand how to use it. So this is how you can develop a simpler, more controlled platform for your clients to use and become more successful.

 

Matthew explained that WordPress Multisite is built into the WordPress core and allows you to create subsites. These act as their own standalone WordPress install but they’re all sharing resources with one WordPress installation. Therefore, you only need to install the plugins, themes, and so on, once. It’s easier for you to manage and use your resources efficiently. For example, you update a plugin once and it’s basically updated on all sites.

 

Matthew uses WaaS – Websites as a service (like Wix, for example) to explain this model. Applying the Saas model to website delivery. These are Turnkey websites delivered automatically via WP multisite.

The focus of the business model is on scale and MRR (monthly recurring revenue). It’s low-cost for customers but also encourages a lot of DIY. Customers have a platform to build the way they want, while using the best tools. But above all, it’s niche-specific. You can be the best website platform for whichever industry you’re targeting.

Top Multisite Plugins according to Matthew Rodela #WCUS

WP Ultimo

WP Ultimo sells subsites on a subscription basis. It allows you to provision subsites to customers on a subscription. With pricing plans, you can limit how many posts you want customers to create per month, for example. Or by how much media they can upload – hosting costs. Certain themes can be available to certain plans. You can create starter content or the ideal site which customers can follow for their own.

KeyPress UI Manager

Rearrange, rename, hide and further modify all backend menus – Admin, Toolbar and Customizer. You can customize or style the dashboard. And soon, users of this plugin will also be able to edit other areas of the admin, like the Dashboard, Gutenberg  and branding.

UpdraftPlus

With multisite you have hundreds using a website from one WP installation which is a bit scary. With this UpdraftPlus plugin, you can backup the entire multisite network, but also individual subsites, which not all plugins can do.

White label CMS

This tool lets you brand your dashboard so you can customize the login page, and add your branding and logo, for example.

Multisite Enhancements and Beyond Multisite

Both sprinkle elements of accessibility which ease Multisite wrangling, but they also:

  • Shows on which sites a plugin is active
  • Display blog and user IDs
  • Various time-saving enhancements

Hosts like WP Engine and Closte

Both are great with subtle differences. WP Engine is one of the more popular hosts. It works with WP Ultimo domain mapping, scales well and has in-built security and caching. It has one-click staging for testing. And with WP Engine, you can convert to multisite in one click. It only counts as one install.

Closte also works with WP Ultimo domain mapping and you get Auto-SSL with WP Ultimo too. However it;s more flexible and the pricing scales according to your usage.

Final tips for running a multisite platform

Many users opt for premium plugins instead of free ones mostly so that they can get premium support. So be picky about plugins offered. Use a managed WP host ideally. Remember image optimization is key to manage disk space bandwidth – WP Smush works well with multisite in this respect. This way you don’t end up killing load time by uploading too many images and so on.

For more info on this topic, check out our take on multisite, or you can follow Matthew’s work here.

How to survive the shift from developer to manager

How to survive the shift from developer to manager - Plesk at WCUS 2019

Brian Thompson currently runs the Web Team at the Mindgrub Technologies digital agency. He’s been working with WordPress since he was a sysadmin managing WordPress website servers in 2011. He then moved to WordPress development in 2012 before he grew into his current management role. This developer to manager shift happened to Brian. And he came to WCUS to share valuable tools and tips on how to effectively lead a development team.

– Manager responsibilities in both good and bad times

– Building team relationships and soliciting good feedback

– Balancing technical development with team collaboration

– Delivering constructive feedback

– Saying “no”

level up - developer to manager

For many developers, being promoted into a managerial role requires a drastic shift in mindset. While many programming paradigms do carry over to being a manager, there are plenty of other skills that most developers just need to “figure out.”

Brian Thompson

Managing developers is like white water rafting

Just like white water rafting, when taking on a lead engineer role, you need to use the proper equipment. Suddenly tasks and responsibilities start coming at you in all directions. From project managers to developers. You will need something like a task tracker to help organize it all.

Brian Thompson - Managing a developer team is like white water rafting

Brian even admitted to using spreadsheets to collect all his employees information because he is a people manager now. He even created an escalation playbook which personally helps him decipher when and how to get involved when there’s an issue.

Going with the flow can be dangerous

While still on the rafting metaphor, before getting in the water, you will be told to go faster or slower than the water but not at the same speed as the water. This goes for management as well. You need to go faster than your projects or your people. Otherwise, if you’re just sitting back and letting the questions come to you – you are not leading, you are following.

As a manager you need to get used to not always being pointed forward and in the right direction. Sometimes it’s not smooth, you don;t always know where you’re going and may bump into things on occasion. Brian says he walks into situations with a plan or some knowledge, and at least the direction he wants to go in. Even if many things are unclear.

Don’t be afraid of bumps in the road

Sometimes you need to lean into the hazard to deal with it. As a manager, you need to give your team direction. Many times, not everyone needs to be on a project. A few people need to work harder than others. Sometimes it’s OK to allow some team members to have a breather.

You need to deal with adversity because things won’t always go well. You’re going to have bad days, but it’s always important to bounce back up. Every bad experience is a learning opportunity and you can always do better.

Saying NO

How to say no - developer to manager - Plesk at WCUS

As a manager, say no is painful, but there are ways to make it easier. It helps to always give a reason. It helps your team understand. Don’t apologize for saying no, because saying sorry just diminishes your answer. It’s your decision to make, and they may not always agree or like it, but it’s not something to be sorry for if you deem it to be correct at the time.

Understandably this can be tricky and can range from rejecting requests on workflows and processes to salary raises. Sometimes you have to say no to a salary increase because performance is lacking. However you can always give a reason and maybe plan to help them get there.

Mentor vs Manager

Being a mentor to somebody should happen outside of management. Both parties needs to want mentorship. You can try dividing your team into those who need more of your guidance, for whatever reason, and those who may need less. Maybe they work more independently or are on a project which does not need any further involvement. You need to be realistic with how much time you can spend giving individual attention, especially if your team is larger.

Brian’s ultimate advice is to also have fun with it. Even if things aren’t always going your way, there is a lot of reward in leading a great web development team. Whether you’re new to management or simply want to improve your team’s performance, these tips are for you. Empower yourself to become the leader that your team needs and can count on.

Achieve better website performance using Maslow’s hierarchy of needs

Achieve better website performance using Maslow’s hierarchy of needs - Plesk

Here at WordCamp US, Steve Persch reveals how web teams can standardize and automate the levels of Marlow’s hierarchy of needs to achieve their goals. Using these tools at any level of the hierarchy can build on a stable foundation and focus upwards towards conversion. 

Like you, Steve Persch knows the pain of trying to juggle different developmental priorities. Steve is a developer with over 13 years’ experience in building WordPress and Drupal sites. “There are always new requests for more functionality, fresh redesigns, and bug fixing”. You need to increase conversions on top of keeping the websites maintained, which may be conflicting at times. Hence why Steve wants to present a way to organize these priorities – the hierarchy of needs for high-performing websites.

Steve Persch

It’s easier to organize these developmental priorities when you view them as building blocks on top of the other. During his funny WordCamp US 2019 lightning session, Steve used Maslow’s hierarchy of needs as a metaphor. Effectively highlighting how web teams leverage solid foundations and standardization in all hierarchy levels to move their focus upwards to the conversion stage.

Maslow’s hierarchy applied to website performance

In Maslow’s hierarchy of needs is a 1943 theory. This sees people motivated by five basic needs: physiological, safety, love, esteem, and self-actualization.

Maslow's hierarchy of needs

At the base, you’ll find the building blocks, which are physiological and safety needs. Things like food, water, health and money, as these are hard to function without. On top of that there is belonging – a community of friends and family, then self-esteem and respect. At the top, you’ll find self actualization, the real purpose. Are you reaching your full potential?

Maslow's hierarchy o fneeds applied to website performance and conversion

In the same way, we can look at a website’s hierarchy of needs. At the bottom, we have the servers running, because without servers, there can be no website at all. Next is safety, you need to keep the ship afloat. Can you get hacked? Will you get a traffic spike that will break something?

Moving further up, there is compliance. Are we compliant with the things we need to be compliant with? Regulations, and so on? Next is quality, especially important since we need to provide the best experience to the user. Also, there is so much noise online that standing out with good quality websites just makes sense from a business perspective.

However at the top there is always conversion. Similar to Maslow’s hierarchy of needs, the apex of the pyramid is the main purpose. This is the reason that your website exists in the first place – conversions. So collectively, we should be aiming to satisfy the need at the top of the pyramid.

WebOps is a team sport

WebOps people - a team sport

Steve specified again that this is not a hierarchy of people, but a hierarchy of needs.  Members of a WebOps team can exist on various or multiple levels of the hierarchy of needs. Each can do their job perfectly, but ultimately their processes and goals should be aligned from the bottom upwards.

“Perfect execution won’t fix a broken culture.” - Steve Persch

These WebOps practices and standardizations are better done as a group.