Author: Humayun Khalid

This article will help you to add your own indexer in Magento 2. Magento 2 has made performance improvements that now allow you to declare one or more shared indexers. You can add a custom indexer using the steps below:

1. Create indexer class
2. Create etc/indexer.xml file.
3. Create etc/mview.xml file.

Example of a custom indexer implementation

In order to push best-selling products to the top of a category listing, you need to process the statistics related to sales which will help in changing the product position dynamically.

1. Create indexer class

Your custom indexer class should implement \Magento\Framework\Indexer\ActionInterface and the indexer should be able to perform three types of operations:

• executeRow($id) – Processing a single entry from a dictionary.
• executeList($ids) – Processing a set of dictionary entries.
• executeFull() – Processing all entities from a specific dictionary.

Create an Indexer folder inside your module’s model folder.

Example: KiwiCommerce\Demo\Model\Indexer;

After creating the Indexer folder, create an indexer class file inside it.

Example:

class CustomIndexer implements \Magento\Framework\Indexer\ActionInterface, \Magento\Framework\Mview\ActionInterface
{
	public function executeFull(); //Should take into account all placed orders in the system

	public function executeList($ids); //Works with a set of placed orders (mass actions and so on)

	public function executeRow($id); //Works in runtime for a single order using plugins

	public function execute($ids); //Used by mview, allows you to process multiple placed orders in the "Update on schedule" mode 	
}

2. Create etc/indexer.xml file.

Create the indexer.xml file inside the etc folder of the module.

Example: KiwiCommerce\Demo\etc\indexer.xml

<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:Indexer/etc/indexer.xsd">
   <indexer id="kiwicommerce_indexer" view_id="kiwicommerce_indexer" class="KiwiCommerce\Demo\Model\Indexer\CustomIndexer">
       <title translate="true">Custom Indexer</title>
       <description translate="true">Custom Indexer Description </description>
   </indexer>
</config>

3. Create etc/mview.xml file.

Next, you need to create an mview.xml file inside the etc folder of the module.

Example: KiwiCommerce\Demo\etc\mview.xml

<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:Mview/etc/mview.xsd">
   <view id="kiwicommerce_indexer" class="KiwiCommerce\Demo\Model\Indexer\CustomIndexer" group="indexer">
       <subscriptions>
           <table name="sales_order" entity_column="entity_id" />
       </subscriptions>
   </view>
</config>

Now when an order is placed, the custom indexer calculates the sorting order of the products and stores this data in the index table so that it can be used in product displaying logic.

You can verify your index on Index Management.

To check the Indexer:

• Log in to the Magento Admin.
• Navigate to System > Index Management.

Facing issues with Magento 2 flow or require expertise and support? Connect with us.

It is true that when it comes to building an eCommerce store, Magento would be the first and only choice due to its ability to be customised in order to meet every requirement the owners may have. Sometimes you may want to play with the variety of colours showing, and for that you need to add a colour picker in the Magento 2 System configuration.

At first it may seem a big task and pretty difficult to achieve, however it is really simple. Below are the exact steps to do this:

• Step 1: Create Attribute
• Step 2: Create pickcolors.js, color.html, di.xml files
• Step 3: Create Pool Modifier Class – Style.php

Note: Replace KiwiCommerce/Attributes from entries in this article to your module name.

Step 1: Create Attribute

Create a product attribute for color with the data given below:

attribute code: my_color

Step 2: Create pickcolors.js, color.html, di.xml files

First of all, create pickcolors.js in your module at the path given below and add the following code:

app/code/KiwiCommerce/Attributes/view/base/web/js/form/element/pickcolors.js

define([
    'Magento_Ui/js/form/element/abstract',
    'mageUtils',
    'jquery',
    'jquery/colorpicker/js/colorpicker'
], function (Abstract, utils, $) {
    'use strict';
    return Abstract.extend({
        defaults: {
            placeholder: $.mage.__('Select Colors'),
            elementTmpl: 'KiwiCommerce_Attributes/form/element/color',
            links: {
                value: '${ $.provider }:${ $.dataScope }'
            }
        },
        /**
         * Calls 'initObservable' of parent
         *
         * @returns {Object} Chainable.
         */
        initObservable: function () {
            this._super()
                .observe('disabled visible value')
                .observe('addText');

            return this;
        },
        /**
         * Initializes regular properties of instance.
         *
         * @returns {Abstract} Chainable.
         */
        initConfig: function () {
            var uid = utils.uniqueid(),
                valueUpdate;
            this._super();
            valueUpdate = this.showFallbackReset ? 'afterkeydown' : this.valueUpdate;
            _.extend(this, {
                uid: uid,
                noticeId: 'notice-' + uid,
                valueUpdate: valueUpdate
            });
            console.log(this);
            return this;
        },
        /**
         * Initialize ColorPicker
         *
         * @returns {boolean}
         */
        initColorPicker: function() {
            var self = this;
            $('[data-role="color-picker"]').ColorPicker({
                color: self.value(),
                onShow: function (colpkr) {
                    $(colpkr).fadeIn(200);
                    return false;
                },
                onHide: function (colpkr) {
                    $(colpkr).fadeOut(200);
                    return false;
                },
                onChange: function (hsb, hex) {
                    $('#color-121').css('backgroundColor', '#' + hex);
                    self.userChanges();
                    self.value('#' + hex);
                    self.hasChanged();
                }
            });
            return false;
        },
        /**
         * Validates itself by it's validation rules using validator object.
         * If validation of a rule did not pass, writes it's message to
         * 'error' observable property.
         *
         * @returns {Object} Validate information.
         */
        validate: function () {
            var value   = this.value(),
                result  = this.checkColor(value),
                message = !this.disabled() && this.visible() ? result.message : '',
                isValid = this.disabled() || !this.visible() || result.passed;

            this.error(message);
            this.bubble('error', message);

            if (!isValid) {
                this.source.set('params.invalid', true);
            }

            return {
                valid: false,
                target: this
            };
        },
        checkColor: function(value) {
            var result = {message: $.mage.__('Color is not valid'), passed:false};
            if (/(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i.test(value)) {
                result = { message: '', passed: true };
            }
            return result;
        }
    });
});

Create color.html in your module at the path given below and add the following code:
app/code/KiwiCommerce/Attributes/view/base/web/template/form/element/color.html

<div class="swatches-visual-col col-default">
   <div class="swatch_window" style="background: #000000"
        data-bind="
        style: {'background-color': value},
        'aria-describedby': noticeId,
        id: uid, disabled: disabled,
        attr: {title: placeholder},
        hasFocus: focused
   "></div>
</div>

Create di.xml in your module at the path given below and add the following code:

app/code/KiwiCommerce/Attributes/etc/adminhtml/di.xml

<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:ObjectManager/etc/config.xsd">
   <virtualType name="Magento\Catalog\Ui\DataProvider\Product\Form\Modifier\Pool">
       <arguments>
           <argument name="modifiers" xsi:type="array">
               <item name="styles" xsi:type="array">
                   <item name="class" xsi:type="string">KiwiCommerce\Attributes\Ui\Modifier\Product\Style</item>
                   <item name="sortOrder" xsi:type="number">25</item>
               </item>
           </argument>
       </arguments>
   </virtualType>
</config>

Step 3: Create Pool Modifier Class – Style.php

Now, create the class Pool Modifier in your module at the path given below and add the following code:

app/code/KiwiCommerce/Attributes/Ui/Modifier/Product/Style.php

<?php
namespace KiwiCommerce\Attributes\Ui\Modifier\Product;

use Magento\Catalog\Ui\DataProvider\Product\Form\Modifier\AbstractModifier;

class Style extends AbstractModifier
{
   public function modifyMeta(array $meta)
   {
       // Color attribute
       $code = 'my_color';
       // Change component js
       $meta['product-details']['children']['container_' . $code]['children'] = array_replace_recursive(
           $meta['product-details']['children']['container_' . $code]['children'], [
           $code => [
               'arguments' => [
                   'data' => [
                       'config' => [
                           'component' => 'KiwiCommerce_Attributes/js/form/element/pickcolors'
                       ]
                   ]
               ]
           ]
       ]);
       return $meta;
   }

   public function modifyData(array $data)
   {
       return $data;
   }
}

Woohoo, now clear the cache and the result will be displayed as shown in the image below:
Product edit page:

If colour is one of the required attributes then you will see an error message while saving the configuration:

That’s it and you can even customize and use this code to place a colour picker anywhere in Magento. Feel free to reach out to us if you find any issues or errors while implementing this code. Wonderful, colourful Magento! ?

No doubt when things revolve around a jQuery widget in Magento 2, it becomes more tricky and takes hours to see final results on screen. To help when this is the case, we at KiwiCommerce are going to teach you how to create a jQuery widget in Magento 2 following a set of simple steps mentioned below:

1. Set up a module and select any PHTML file for calling custom jQuery widget.
2. Create a custom jQuery widget.
3. data-mage-init attribute for calling the newly created custom widget.
4. Clear cache and check the form.

1. Set up a module and select any PHTML file for calling custom jQuery widget.

To start you need to create a module and override any phtml file to call your custom widget. In this example, we have the contact phtml file:
app\design\frontend\VendorName\ModuleName\Magento_Contact\templates\form.phtml

2. Create a custom jQuery widget.

The next step is to create a custom js file for creating a custom jquery widget:
app\code\VendorName\Modulename\view\frontend\web\js\kiwicount.js

And below is the basic code structure:

define([
   'jquery',
   'underscore',
   'jquery/ui',
   'Magento_Ui/js/modal/confirm',
   'mage/translate'
], function ($, _) {
   'use strict';

   $.widget('mage.kiwicount',{

	// Your custom code and custom methods will be here 	

 });

    return $.mage.kiwicount;

});

In the define section, state the jquery name that you want or you can simply put jQuery in the define section.
We will be using only jQuery and jQueryUi and as a result we will remove the extra define code from Js. Your code will now look like the below:

define([
   'jquery',
   'jquery/ui'
], function ($, _) {
   'use strict';

   $.widget('mage.kiwicount',{

	// Your custom code and custom methods will be here 	

 });

    return $.mage.kiwicount;

});

3. data-mage-init attribute for calling your custom Widget.

Now let’s get back to our file:
app\design\frontend\VendorName\ModuleName\Magento_Contact\templates\form.phtml

In this file we need to check the number of characters for the text area field and to do so we need to call our custom jQuery widget as shown in below code:

<textarea name="comment" id="comment" title="<?= $block->escapeHtmlAttr(__('Comment')) ?>" class="input-text"
 data-mage-init='{"KiwiCommerce_LoginAsCustomer/js/kiwicount": {"maxlen":"150","messagebox":"charNum"}
}'></textarea>

<span id="charNum"></span>

Where : KiwiCommerce_LoginAsCustomer/js/kiwicount is the path of JS file
Maxlen variable to pass in jquery widget as config array we can get all these arguments there using config.maxlen

Coming back to our custom widget js file, apply the code for validation and receive the argument:

define([
   'jquery'
], function ($, _) {
   'use strict';

   $.widget('mage.kiwicount',{

       _create: function(config,element) {

           this._case = $(this.element);
           $(this._case).keyup(function () {
               var max = config.maxlen;
               var len = $(this.element).length;
               if (len >= max) {
                   $('#'+config.messagebox).text(' you have reached the limit');
               } else {
                   var char = max - len;
                  $('#'+config.messagebox).text(char + ' characters left');

               }
           });
       }
   });

    return $.mage.kiwicount;

});

In the above code snippet, we have added a _create function which is a constructor. However, we only need to check the length of the element so we have directly received the constructor.
We also have two objects, named as config and element:

Config :
The argument which is sent with the variable to this custom jquery widget:
We can access all passing argument using config.messagebox where messagebox is the variable name.

Element :
All property of the current element from where it is called, in our case we have the element <textarea>.
We can use any property of the element using: this.element

4. Clear the cache and flush and check you phtml page(Contact page)

Clear the cache :

php bin\magento cache:clear
or
php bin\magento c:c

Clear the flush:

php bin\magento cache:flush
or
php bin\magento c:f

After that you will be able to find the changes of character limit Jquery widget working on contact us page textarea.

You now know how to create a jQuery widget specifically in Magento 2. If you get stuck while creating this widget we at KiwiCommerce will be happy to help you out. Feel free to reach out to us. ?

Undoubtedly, the Magento 2 installation process using the wizard in a browser is quite cumbersome and time consuming, especially when we use sample data. To overcome that, we at KiwiCommerce have got a completely new tactic to install Magento 2 within minutes, and that is with the use of CLI.

Below is a couple of steps that lets you install and run Magento 2 in no time:

Step 1: Download Magento 2.

Here, we can get the Magento 2 Files using composer or directly get a zip file from https://magento.com/tech-resources/download.

Using composer

Get the latest Magento version by running the below command in the console:

composer create-project --repository-url=https://repo.magento.com/ magento/project-community-edition <directory>

Or to get a specific version of Magento, add an extra argument in command as below:

composer create-project --repository-url=https://repo.magento.com/ magento/project-community-edition 2.1.7 <directory>

The <directory> is the location where you want to install Magento. If you do not specify <directory> then it creates project-community-edition.

Download direct Zip

We can download the agento 2 full release with or without sample data from https://magento.com/tech-resources/download and extract it to where you want to install. Please check the below screenshot to see this:

Step 2: Install using CLI

After setting up the Magento 2 file system, run the below command in CLI from the Magento 2 root folder to install it quickly:

php bin/magento setup:install \
--base-url=http://127.0.0.1/magento/ \
--db-host=localhost \
--db-name=magento \
--db-user=root \
--db-password=123456 \
--admin-firstname=root \
--admin-lastname=localhost \
[email protected] \
--admin-user=admin \
--admin-password=admin123 \
--backend-frontname=admin \
--language=en_US \
--currency=USD \
--timezone=America/Chicago \
--use-rewrites=1

Check the above options in detail below:

Here I’ve added some options in the above command which I think are required, but are not compulsory. The above command should be edited to your needs and executed from the Magento 2 root directory. If everything went correctly, you will be informed that the installation has been completed.

For more detail please refer to this link: https://devdocs.magento.com/guides/v2.2/install-gde/install/cli/install-cli-install.html#instgde-install-cli-magento

Conclusion

You’re done! Now you know the complete process to install Magento 2 using CLI, and of course the best bit it that you can do it quickly. If you get stuck somewhere while doing this, please connect with us and we will be glad to help you ?

This article will help you to understand how the cron group works in Magento 2.

A cron group is a logical group that allows you to easily run a cron for more than one process at a time. Most Magento modules use the default cron group; some modules use the index group.

Example : <your component base dir>/<vendorname>/module-<name>/etc/crontab.xml

<config>
    <group id="<group_name>">
        <job name="<job_name>" instance="<classpath>" method="<method>">
            <schedule><time></schedule>
        </job>
    </group>
</config>

Here when defining the crontab for the module we need to define the group name too. Here group_name is the name of the cron group. The group name doesn’t have to be unique and we can run the cron for one group at a time.

Create a custom cron group

Declare a new group and specify its configuration options (all of which run in the store’s view scope) through the cron_groups.xml file, located at:
<your component base dir>/<vendorname>/module-<name>/etc/cron_groups.xml

Example:

<config>
    <group id="<group_name>">
        <schedule_generate_every>1</schedule_generate_every>
        <schedule_ahead_for>4</schedule_ahead_for>
        <schedule_lifetime>2</schedule_lifetime>
        <history_cleanup_every>10</history_cleanup_every>
        <history_success_lifetime>60</history_success_lifetime>
        <history_failure_lifetime>600</history_failure_lifetime>
        <use_separate_process>1</use_separate_process>
    </group>
</config>

Where:

• group_name – Name of the custom group.
• schedule_generate_every – Frequency (in minutes) that schedules are written to the cron_schedule table.
• schedule_ahead_for – Time (in minutes) in advance that schedules are written to the cron_schedule table.
• schedule_lifetime – Window of time (in minutes) that cron job must start or will be considered missed (“too late” to run).
• history_cleanup_every – Time (in minutes) that cron history is kept in the database.
• history_success_lifetime – Time (in minutes) that the record of successfully completed cron jobs is kept in the database.
• history_failure_lifetime – Time (in minutes) that the record of failed cron jobs is kept in the database.
• use_separate_process – This feature is available only for Magento 2.1 and later.

Verify your custom cron group

Step 1
Run Magento cron jobs for your custom group:

php bin/magento cron:run --group="group_name"

Execute this multiple times to check and confirm.

Step 2
Clean the Magento cache:

php bin/magento cache:clean

Step 3
Log in to the Magento Admin as an administrator.

Step 4
Click Stores > Configuration > Advanced > System.

Step 5
In the right pane, expand Cron. Your group of crons are displayed as follows:

Thanks for reading! ?

Magento 2 provides a very powerful symphony based command-line interface that performs installation and configuration tasks. The new command-line interface makes the life of both developers and system administrators much easier when performing multiple tasks, such as installing Magento, installing or upgrading custom or third-party extensions, clearing the cache, managing indexes, deploying static view files, setting application mode, creating database backups and much more.

This is a major improvement when compared to Magento 1 as it’s highly customizable and extendable so you can easily plug in your own commands provided by your Magento 2 extensions.

In this article, we will throw some light on command naming format which will help you to remember it easily and will list out some of the most useful commands in Magento 2.

Command naming format

A command name is a part of the command which defines behavior of the command on the very highest level. Any command goes right after the command’s name in the code, for example, in:

php bin/magento setup:static-content:deploy

• bin/magento is the command’s name
• setup:static-content:deploy is the name of the command.

If you’ve got a Magento installation handy then go to root directory of your installation and enter the following to display the current list of commands:

php bin/magento list

Format: group:[subject:]action

group

It represents a group of related commands. Commands in a group display in a list, which in turn makes it easier for the user to find the desired command. To find a group name for a command, imagine an subject area where it can be used.

subject

It’s a subject for the action. The subject is optional, but it can be useful for defining sets of commands that work with the same object. If a subject is represented by a compound word, use a dash or hyphen character to separate the words.

action

It is an action that the command does.

For examples:

General commands: just a group and an action

php bin/magento cache:clean
php bin/magento cron:install

Set of commands with a subject

php bin/magento admin:user:create
php bin/magento catalog:images:resize

Some of the most frequently used commands in Magento CLI

Install and upgrade a module using the command line interface

php bin/magento setup:upgrade

To prevent generated static view files from being deleted when setup:upgrade

php bin/magento setup:upgrade --keep-generated

Display the current running Magento application mode using the command line interface

php bin/magento deploy:mode:show

Switch to the developer or production application mode using the command line interface

php bin/magento deploy:mode:set developer (or production)

Skips the clearing and regeneration of static content when switching application mode

php bin/magento deploy:mode:set developer --skip-compilation

Deploy static view files in production and default mode using the command line interface

php bin/magento setup:static-content:deploy

Deploy static view files in any mode (very useful when you need to deploy static content in which an application is running on developer mode)

php bin/magento setup:static-content:deploy -f

Generate static view files for only the specified themes using the command line interface

php bin/magento setup:static-content:deploy --theme Magento/luma --theme VendorName/theme

Generate files only for the specified languages using the command line interface

php bin/magento setup:static-content:deploy en_US

Compile dependency injection using the command line interface

php bin/magento setup:di:compile

Reindexing all magento indexers using the command line interface

php bin/magento indexer:reindex

View the list of indexers using the command line interface

php bin/magento indexer:info

Show the status of the indexer using the command line interface

php bin/magento indexer:status

Show the mode of all indexers using the command line interface

php bin/magento indexer:show-mode

Check cache type status using the command line interface

php bin/magento cache:status

Enable/disable all cache types using the command line interface

php bin/magento cache:enable (or disable)

Enable/disable specified cache type using the command line interface

php bin/magento cache:disable (or enable) [cache_type]

Magento recommends that you disable only the cache types you don’t need while developing for best practice, instead of disabling all caches. This increases unnecessary load time of all pages and as a result it may also increase your development time.

Enable maintenance mode using the command line interface

php bin/magento maintenance:enable

Allow IP on maintenance mode using the command line interface

php bin/magento maintenance:allow-ips --ip=192.0.2.10 --ip=192.0.2.20

Flush or clean the Magento cache using the command line interface

php bin/magento cache:flush (or clean)

Let’s try to understand the main difference between cleaning and flushing cache types.

• Cleaning a cache type deletes all items from enabled Magento cache types only. In other words, this option does not affect other processes or applications because it cleans only the cache that Magento uses. Please note that disabled cache types are not cleaned.
• Flushing a cache type purges the cache storage, which might affect other processes for applications that are using the same storage. Flush cache types if you’ve already tried cleaning the cache and you’re still having issues that you cannot isolate.

If you find this or anything else difficult in your Magento installation, configuration or deployment best practices, we’re happy to help you. Feel free to get in touch!

Experts across any industry will admit that there is no hard formula for success. Regardless of whether you’re an instructor, specialist, legal advisor or work in retail, there might be some industry specific procedures and rules to stick to, yet a few of the best practices across any industry include strategising, monitoring, reviewing and communicating.

Project management is no different. Most project managers will learn the basics at the very beginning as in other industries, including the best ways to plan and budget their projects, but after some time each individual finds their own specific techniques and ways to deal with projects, big or small, and it’s these techniques that make them successful or not. We like to think that our Magento project managers have that certain X factor that sets them apart from the rest, and happily, our clients confirm this regularly!

From the outside, managing a project appears to be so simple. You set tasks, due dates, a financial plan, item owners from within the business etc. and it seems you are done with planning the project at this point, but in reality, project management is not as simple and straightforward as it seems to be. Sometimes individuals are appointed to the project (from both client and agency side) who aren’t as qualified as needed, don’t understand what the project expects from them or they provide incorrect or partial information. Sometimes business priorities mean changes to timescales and therefore due dates can’t be met. Put all the more succinctly, project management is difficult, forever changing and requires thorough attention.

So what can organisations and project managers do to enhance the chances of the project being finished on time and to a financial plan? Here are the two most important aspects to consider for successful project management that I have depended on for years – the ones I can’t resist the urge to share!

Client Involvement

The client needs to know as much about a project then the team does. The client is the one with the vision and, let’s be realistic, the gold!

So how do we proceed with the client positively? Communication is above all – the more we keep in contact, the better it is for the project. The project manager and the team will have a million things to ask about the project and the client always has questions about progress; so our project managers give the customer weekly progress reports along with requirements in order to ensure progress can be made. There may be issues that can be addressed rapidly through regular communication, meaning work doesn’t need to come to a standstill while we wait for a response.

While our teams work in the background progressing the tasks, the client fulfills the needs of the project by approving tasks, providing as much information and authorisation as required and characterising the project scope to the project manager and the team. The frequency of project reviews majorly depends on the complexity of the project, however we like to have weekly catch ups over the phone with our clients as a minimum. The less complex projects may have fewer reviews as these may not be necessary, whereas more complex projects will require frequent meetings which are essential for the progress of the project.

The Team (Of Course)

The next important aspect of your project management is obviously your development team, because they are the ones responsible for writing the code, however their role is not simply development. They will review the code, help to indicate any future requirements and give information, suggestions and guidance on the project progression from a technical point of view. As a project develops we always find there are queries from and suggestions for the client, so the project managers will loop in the team members to work with them to suggest a specific way forward at particular pit-stops, and to help the clients with their more complex queries. A successful team should have the capacity to overcome any barriers that may happen amid the project, if the project is managed efficiently and the team members work together.

It is also important for the project manager to get to know the team. When they get to know the team they are working with it takes them one step closer to making the project successful. This is because learning about each individual in the team gives them the ability to delegate tasks to the person who’s most capable of executing them correctly and quickly.

Finally, everybody cherishes getting positive feedback, even your clients. Make sure you inform your team members if a client compliments them and give them a little reward; even if it’s just an early finish or a box of chocolates. A little bit of recognition goes a long way and will encourage other team members to go the extra mile to please your clients also. Likewise if your team feel a client is particularly helpful and responsive, allowing them to progress the project without delay, it’s nice to drop them a note they can send upwards on their side. Positive feedback is always welcome and helps build a long term relationship. You may even get a client quote or testimonial for your website or marketing material down the line!

What Do You Think?

Of course, we believe the above aspects are the principal factors that you need to keep in mind when managing a project, however factors like good organisation, use of appropriate technologies, the team formation, clients expectations, workflow, budget and outcome means that every project is unique. The main thing to remember is that even though you may be considering a number of factors, if you keep communication at the forefront you’ll all be working collectively to build a project you can be proud of!

So what about you? Do you have your own project management secrets? Let me know in the comments section below!