The whole code and examples are available in a GitHub repository; it comes packaged as a simple Symfony project and provides a Docker image.

Create a Google Project and Configure Sheets API​

First, let's configure a new Google Console project to enable Sheets API.

Open the Google Cloud Console and create a new project:

Click on Enable APIs and Service, search for Sheets API, enable the service:

Once enabled, we can configure the service:

We now create credentials, in this tutorial, we'll use Application data access:

We need to create a service account (the generated email will be useful later 💡):

We edit the service account to create a new key, using the json type:

We can now download the key file in local and rename it to credentials.json.

The bit tedious configuration part is over!

Create and Share a Google Sheets​

We can create a Google Sheets document. In this tutorial, I use a collection of movies:

A spreadsheet can contain several sheets; this one has a single sheet named Sheet1.

We have to share this document with the previously generated service account email (we set Editor permissions to allow the update of the sheets):

Install and Configure the PHP Client​

Let's install the Google PHP API client:

composer require google/apiclient

The client is configured with the credentials.json:

// configure the Google Client
$client = new \Google_Client();
$client->setApplicationName('Google Sheets API');
$client->setScopes([\Google_Service_Sheets::SPREADSHEETS]);
$client->setAccessType('offline');
// credentials.json is the key file we downloaded while setting up our Google Sheets API
$path = 'data/credentials.json';
$client->setAuthConfig($path);

// configure the Sheets Service
$service = new \Google_Service_Sheets($client);

Get the Spreadsheet​

We use the Sheets service to retrieve the Spreadsheet object:

// the spreadsheet id can be found in the url https://docs.google.com/spreadsheets/d/143xVs9lPopFSF4eJQWloDYAndMor/edit
$spreadsheetId = '143xVs9lPopFSF4eJQWloDYAndMor';
$spreadsheet = $service->spreadsheets->get($spreadsheetId);
var_dump($spreadsheet);

Fetch All the Rows of a Sheet​

We read all the rows of a given sheet:

// get all the rows of a sheet
$range = 'Sheet1'; // here we use the name of the Sheet to get all the rows
$response = $service->spreadsheets_values->get($spreadsheetId, $range);
$values = $response->getValues();
var_dump($values);

The result:

array(10) {
  [0]=>
  array(6) {
    [0]=>
    string(2) "id"
    [1]=>
    string(5) "title"
    [2]=>
    string(6) "poster"
    [3]=>
    string(8) "overview"
    [4]=>
    string(12) "release_date"
    [5]=>
    string(6) "genres"
  }
  [1]=>
  array(6) {
    [0]=>
    string(6) "287947"
    [1]=>
    string(7) "Shazam!"
    [2]=>
    string(63) "https://image.tmdb.org/t/p/w500/xnopI5Xtky18MPhK40cZAGAOVeV.jpg"
    [3]=>
    string(98) "A boy is given the ability to become an adult superhero in times of need with a single magic word."
    [4]=>
    string(10) "1553299200"
    [5]=>
    string(23) "Action, Comedy, Fantasy"
  }
  ... more lines
}

Fetch a Few Rows by Using a Range​

We read the ten first lines of our Google Sheets:

// we define here the expected range, columns from A to F and lines from 1 to 10
$range = 'Sheet1!A1:F10';
$response = $service->spreadsheets_values->get($spreadsheetId, $range);
$values = $response->getValues();
var_dump($values);

Fetch Only Cells of a Given Column​

We read the cells of a given column to avoid fetching everything:

$range = 'Sheet1!B1:B21'; // the column containing the movie title
$response = $service->spreadsheets_values->get($spreadsheetId, $range);
$values = $response->getValues();
var_dump($values);

Convert Rows into JSON Objects​

In many cases, it's easier to manipulate each row as an independent object. Let's transform each row into an associative array.

// Fetch the rows
$range = 'Sheet1';
$response = $service->spreadsheets_values->get($spreadsheetId, $range);
$rows = $response->getValues();
// Remove the first one that contains headers
$headers = array_shift($rows);
// Combine the headers with each following row
$array = [];
foreach ($rows as $row) {
    $array[] = array_combine($headers, $row);
}
var_dump($array);

The result is:

array(21) {
  [0]=>
  array(6) {
    ["id"]=>
    string(6) "287947"
    ["title"]=>
    string(7) "Shazam!"
    ["poster"]=>
    string(63) "https://image.tmdb.org/t/p/w500/xnopI5Xtky18MPhK40cZAGAOVeV.jpg"
    ["overview"]=>
    string(98) "A boy is given the ability to become an adult superhero in times of need with a single magic word."
    ["release_date"]=>
    string(10) "1553299200"
    ["genres"]=>
    string(23) "Action, Comedy, Fantasy"
  }
  [1]=>
  array(6) {
    ["id"]=>
    string(6) "299537"
    ["title"]=>
    string(14) "Captain Marvel"
    ["poster"]=>
    string(63) "https://image.tmdb.org/t/p/w500/AtsgWhDnHTq68L0lLsUrCnM7TjG.jpg"
    ["overview"]=>
    string(307) "The story follows Carol Danvers as she becomes one of the universe’s most powerful heroes when Earth is caught in the middle of a galactic war between two alien races. Set in the 1990s, Captain Marvel is an all-new adventure from a previously unseen period in the history of the Marvel Cinematic Universe."
    ["release_date"]=>
    string(10) "1551830400"
    ["genres"]=>
    string(34) "Action, Adventure, Science Fiction"
  }
  // ... more rows
}

This new structure allows us to manipulate each row as a specific JSON object, applying transformations or streaming its processing.

We can also convert it into a JSON string with a single line of code.

$jsonString = json_encode($array, JSON_PRETTY_PRINT);
print($jsonString);

[
    {
        "id": "287947",
        "title": "Shazam!",
        "poster": "https:\/\/image.tmdb.org\/t\/p\/w500\/xnopI5Xtky18MPhK40cZAGAOVeV.jpg",
        "overview": "A boy is given the ability to become an adult superhero in times of need with a single magic word.",
        "release_date": "1553299200",
        "genres": "Action, Comedy, Fantasy"
    },
    {
        "id": "299537",
        "title": "Captain Marvel",
        "poster": "https:\/\/image.tmdb.org\/t\/p\/w500\/AtsgWhDnHTq68L0lLsUrCnM7TjG.jpg",
        "overview": "The story follows Carol Danvers as she becomes one of the universe\u2019s most powerful heroes when Earth is caught in the middle of a galactic war between two alien races. Set in the 1990s, Captain Marvel is an all-new adventure from a previously unseen period in the history of the Marvel Cinematic Universe.",
        "release_date": "1551830400",
        "genres": "Action, Adventure, Science Fiction"
    },
...

Append a New Row​

We write a new row at the end of the sheet:

$newRow = [
    '456740',
    'Hellboy',
    'https://image.tmdb.org/t/p/w500/bk8LyaMqUtaQ9hUShuvFznQYQKR.jpg',
    "Hellboy comes to England, where he must defeat Nimue, Merlin's consort and the Blood Queen. But their battle will bring about the end of the world, a fate he desperately tries to turn away.",
    '1554944400',
    'Fantasy, Action'
];
$rows = [$newRow]; // you can append several rows at once
$valueRange = new \Google_Service_Sheets_ValueRange();
$valueRange->setValues($rows);
$range = 'Sheet1'; // the service will detect the last row of this sheet
$options = ['valueInputOption' => 'USER_ENTERED'];
$service->spreadsheets_values->append($spreadsheetId, $range, $valueRange, $options);

When using USER_ENTERED as valueInputOption the service will parse the data the same way as when you're typing it directly into the Google Sheets UI. It means the strings will be converted into dates, links, etc, depending on their formats.

We can also use the RAW input option to keep the data unchanged.

Update an Existing Row​

We replace an existing row by new values for its cells:

$updateRow = [
    '456740',
    'Hellboy Updated Row',
    'https://image.tmdb.org/t/p/w500/bk8LyaMqUtaQ9hUShuvFznQYQKR.jpg',
    "Hellboy comes to England, where he must defeat Nimue, Merlin's consort and the Blood Queen. But their battle will bring about the end of the world, a fate he desperately tries to turn away.",
    '1554944400',
    'Fantasy, Action'
];
$rows = [$updateRow];
$valueRange = new \Google_Service_Sheets_ValueRange();
$valueRange->setValues($rows);
$range = 'Sheet1!A2'; // where the replacement will start, here, first column and second line
$options = ['valueInputOption' => 'USER_ENTERED'];
$service->spreadsheets_values->update($spreadsheetId, $range, $valueRange, $options);

Delete Some Rows​

We delete some rows by specifying a range of cells to clear:

$range = 'Sheet1!A23:F24'; // the range to clear, the 23th and 24th lines
$clear = new \Google_Service_Sheets_ClearValuesRequest();
$service->spreadsheets_values->clear($spreadsheetId, $range, $clear);

Download the Code and Examples​

You can find all the code and examples in this GitHub repository.

It's packaged as a simple Symfony project, a set of commands, it also comes with a Docker image. 🐋

In this tutorial, we will learn how to perform the most common manipulation, such as encoding, decoding, and converting JSON to Array and Array to JSON with the help of examples.

We'll also discover how to read and write JSON files in PHP. Finally, we'll look at how to stream a big JSON file while using very little memory.

The whole code and examples are available in a GitHub repository; it comes packaged as a simple Symfony project and provides a Docker image.

JSON String Example​

In this tutorial, we'll use the following JSON string containing a list of movies and their properties.

[
    {
        "id": "287947",
        "title": "Shazam!",
        "poster": "https://image.tmdb.org/t/p/w500/xnopI5Xtky18MPhK40cZAGAOVeV.jpg",
        "overview": "A boy is given the ability to become an adult superhero in times of need with a single magic word.",
        "release_date": "1553299200",
        "genres": [
            "Action",
            "Comedy",
            "Fantasy"
        ]
    },
    {
        "id": "299537",
        "title": "Captain Marvel",
        "poster": "https://image.tmdb.org/t/p/w500/AtsgWhDnHTq68L0lLsUrCnM7TjG.jpg",
        "overview": "The story follows Carol Danvers as she becomes one of the universe\u2019s most powerful heroes when Earth is caught in the middle of a galactic war between two alien races. Set in the 1990s, Captain Marvel is an all-new adventure from a previously unseen period in the history of the Marvel Cinematic Universe.",
        "release_date": "1551830400",
        "genres": [
            "Action",
            "Adventure",
            "Science Fiction"
        ]
    }
]

Convert a JSON String to an Associative Array Using json_decode​

We use json_decode to convert (decode) the string to a PHP associative array.

The second parameter of json_decode specifies if we want to get each JSON object as an associative array or as an object. Here, we go for the associative array option.

$jsonString = '[{"id":"287947","title":"Shazam!","poster":"https:\/\/image.tmdb.org\/t\/p\/w500\/xnopI5Xtky18MPhK40cZAGAOVeV.jpg","overview":"A boy is given the ability to become an adult superhero in times of need with a single magic word.","release_date":"1553299200","genres":["Action","Comedy","Fantasy"]},{"id":"299537","title":"Captain Marvel","poster":"https:\/\/image.tmdb.org\/t\/p\/w500\/AtsgWhDnHTq68L0lLsUrCnM7TjG.jpg","overview":"The story follows Carol Danvers as she becomes one of the universe\u2019s most powerful heroes when Earth is caught in the middle of a galactic war between two alien races. Set in the 1990s, Captain Marvel is an all-new adventure from a previously unseen period in the history of the Marvel Cinematic Universe.","release_date":"1551830400","genres":["Action","Adventure","Science Fiction"]}]';
$jsonArray = json_decode($jsonString, true); // true for associative arrays, false for objects
var_dump($jsonArray);

The result is an array containing one associative array for each movie. The keys of each associative array are the fields of the JSON object.

array(2) {
  [0]=>
  array(6) {
    ["id"]=>
    string(6) "287947"
    ["title"]=>
    string(7) "Shazam!"
    ["poster"]=>
    string(63) "https://image.tmdb.org/t/p/w500/xnopI5Xtky18MPhK40cZAGAOVeV.jpg"
    ["overview"]=>
    string(98) "A boy is given the ability to become an adult superhero in times of need with a single magic word."
    ["release_date"]=>
    string(10) "1553299200"
    ["genres"]=>
    array(3) {
      [0]=>
      string(6) "Action"
      [1]=>
      string(6) "Comedy"
      [2]=>
      string(7) "Fantasy"
    }
  }
  [1]=> // ... the second movie
}

Convert an Associative Array to a JSON string Using json_encode​

We use json_encode to convert (encode) the associative array to a JSON string.

The second parameter of json_encode specifies the format of the string. We can go for the compact option by default. We can also use the pretty format; it includes line breaks and spaces to make the result more human-readable.

$jsonArray = [
    [
        "id" => "287947",
        "title" => "Shazam!",
        "poster" => "https://image.tmdb.org/t/p/w500/xnopI5Xtky18MPhK40cZAGAOVeV.jpg",
        "overview" => "A boy is given the ability to become an adult superhero in times of need with a single magic word.",
        "release_date" => "1553299200",
        "genres"=> ["Action", "Comedy", "Fantasy"]
    ],
    [
        "id" => "299537",
        "title" => "Captain Marvel",
        "poster" => "https://image.tmdb.org/t/p/w500/AtsgWhDnHTq68L0lLsUrCnM7TjG.jpg",
        "overview" => "The story follows Carol Danvers as she becomes one of the universe’s most powerful heroes when Earth is caught in the middle of a galactic war between two alien races. Set in the 1990s, Captain Marvel is an all-new adventure from a previously unseen period in the history of the Marvel Cinematic Universe.",
        "release_date" => "1551830400",
        "genres"=> ["Action", "Adventure", "Science Fiction"]
    ]
];
// compact format
$compactJsonString = json_encode($jsonArray);
echo $compactJsonString.PHP_EOL;
// pretty human-readable format
$prettyJsonString = json_encode($jsonArray, JSON_PRETTY_PRINT);
echo $prettyJsonString.PHP_EOL;

The compact JSON string format:

[{"id":"287947","title":"Shazam!","poster":"https:\/\/image.tmdb.org\/t\/p\/w500\/xnopI5Xtky18MPhK40cZAGAOVeV.jpg","overview":"A boy is given the ability to become an adult superhero in times of need with a single magic word.","release_date":"1553299200","genres":["Action","Comedy","Fantasy"]},{"id":"299537","title":"Captain Marvel","poster":"https:\/\/image.tmdb.org\/t\/p\/w500\/AtsgWhDnHTq68L0lLsUrCnM7TjG.jpg","overview":"The story follows Carol Danvers as she becomes one of the universe\u2019s most powerful heroes when Earth is caught in the middle of a galactic war between two alien races. Set in the 1990s, Captain Marvel is an all-new adventure from a previously unseen period in the history of the Marvel Cinematic Universe.","release_date":"1551830400","genres":["Action","Adventure","Science Fiction"]}]

The pretty JSON string format:

[
    {
        "id": "287947",
        "title": "Shazam!",
        "poster": "https:\/\/image.tmdb.org\/t\/p\/w500\/xnopI5Xtky18MPhK40cZAGAOVeV.jpg",
        "overview": "A boy is given the ability to become an adult superhero in times of need with a single magic word.",
        "release_date": "1553299200",
        "genres": [
            "Action",
            "Comedy",
            "Fantasy"
        ]
    },
    {
        "id": "299537",
        "title": "Captain Marvel",
        "poster": "https:\/\/image.tmdb.org\/t\/p\/w500\/AtsgWhDnHTq68L0lLsUrCnM7TjG.jpg",
        "overview": "The story follows Carol Danvers as she becomes one of the universe\u2019s most powerful heroes when Earth is caught in the middle of a galactic war between two alien races. Set in the 1990s, Captain Marvel is an all-new adventure from a previously unseen period in the history of the Marvel Cinematic Universe.",
        "release_date": "1551830400",
        "genres": [
            "Action",
            "Adventure",
            "Science Fiction"
        ]
    }
]

Read a JSON File in PHP​

We'll use the same format here; the file movies-10.json contains a list of 10 movies:

[
    {
        "id": "287947",
        "title": "Shazam!",
        "poster": "https://image.tmdb.org/t/p/w500/xnopI5Xtky18MPhK40cZAGAOVeV.jpg",
        "overview": "A boy is given the ability to become an adult superhero in times of need with a single magic word.",
        "release_date": "1553299200",
        "genres": [
            "Action",
            "Comedy",
            "Fantasy"
        ]
    },
    {
        "id": "299537",
        "title": "Captain Marvel",
        "poster": "https://image.tmdb.org/t/p/w500/AtsgWhDnHTq68L0lLsUrCnM7TjG.jpg",
        "overview": "The story follows Carol Danvers as she becomes one of the universe\u2019s most powerful heroes when Earth is caught in the middle of a galactic war between two alien races. Set in the 1990s, Captain Marvel is an all-new adventure from a previously unseen period in the history of the Marvel Cinematic Universe.",
        "release_date": "1551830400",
        "genres": [
            "Action",
            "Adventure",
            "Science Fiction"
        ]
    },
    // ... and more lines
]

We parse the JSON file using native PHP functions:

1. Open and read the file's content with file_get_contents($path)
2. Convert the JSON string to an associative array with json_decode($jsonString, true)
3. Print the associative array with var_dump($jsonData)

$path = 'data/movies-10.json';
$jsonString = file_get_contents($path);
$jsonData = json_decode($jsonString, true);
var_dump($jsonData);

The result:

array(10) {
  [0]=>
  array(6) {
    ["id"]=>
    string(6) "287947"
    ["title"]=>
    string(7) "Shazam!"
    ["poster"]=>
    string(63) "https://image.tmdb.org/t/p/w500/xnopI5Xtky18MPhK40cZAGAOVeV.jpg"
    ["overview"]=>
    string(98) "A boy is given the ability to become an adult superhero in times of need with a single magic word."
    ["release_date"]=>
    string(10) "1553299200"
    ["genres"]=>
    array(3) {
      [0]=>
      string(6) "Action"
      [1]=>
      string(6) "Comedy"
      [2]=>
      string(7) "Fantasy"
    }
  }
  // ... and more lines
}

Write a JSON File in PHP​

We create and write a JSON file from an associative array:

1. Convert the list of associative array to a JSON string with json_encode($jsonData, JSON_PRETTY_PRINT)
2. Open the new JSON file with fopen($path, 'w')
3. Write the JSON string with fwrite($fp, $jsonString)
4. Close the file with fclose($fp)

$path = 'data/new-file.json';
// JSON data as an array
$jsonData = [
    [
        "id" => "287947",
        "title" => "Shazam!",
        "poster" => "https://image.tmdb.org/t/p/w500/xnopI5Xtky18MPhK40cZAGAOVeV.jpg",
        "overview" => "A boy is given the ability to become an adult superhero in times of need with a single magic word.",
        "release_date" => "1553299200",
        "genres"=> ["Action", "Comedy", "Fantasy"]
    ],
    [
        "id" => "299537",
        "title" => "Captain Marvel",
        "poster" => "https://image.tmdb.org/t/p/w500/AtsgWhDnHTq68L0lLsUrCnM7TjG.jpg",
        "overview" => "The story follows Carol Danvers as she becomes one of the universe’s most powerful heroes when Earth is caught in the middle of a galactic war between two alien races. Set in the 1990s, Captain Marvel is an all-new adventure from a previously unseen period in the history of the Marvel Cinematic Universe.",
        "release_date" => "1551830400",
        "genres"=> ["Action", "Adventure", "Science Fiction"]
    ]
];
// Convert JSON data from an array to a string
$jsonString = json_encode($jsonData, JSON_PRETTY_PRINT);
// Write in the file
$fp = fopen($path, 'w');
fwrite($fp, $jsonString);
fclose($fp);

CSV for Comma-Separated Values is another standard format to exchange data between applications, and it's pretty straightforward to convert from JSON to CSV (and from CSV to JSON).

Out of Memory!​

When reading a large JSON file, you'll quickly encounter a memory consumption issue: "Error: Allowed memory size of X bytes exhausted".

It's normal! The native methods load the entire content in memory. You can raise the memory_limit until reaching the limits of memory of your server. Some files are so large that it will not be enough.

Great news, there is an alternative approach; let's explore it.

Stream a Big JSON File​

We use a JSON file including 500k movies records; it weights almost 300MB:

-rw-rw-rw- 1 nico nico 284M mars  12 13:20 movies-500000.json

We'll install and use the halaxa/json-machine library.

composer require halaxa/json-machine

JSON Machine is an efficient PHP JSON stream parser based on generators.

Read our big JSON file:

// I'm using here the Symfony Console & StopWatch components
$section = 'read_json_file';
$this->stopwatch->start($section);
$path = 'data/movies-500000.json';
// open the JSON file
$jsonData = Items::fromFile($path, ['decoder' => new ExtJsonDecoder(true)]);
// iterate over each document
foreach ($jsonData as $object) {
    // do nothing, but we want to browse each object
    // echo $object["title"];
}
$this->stopwatch->stop($section);
$output->writeln("I read ".iterator_count($jsonData)." rows from the JSON File ".$path);
$output->writeln((string) $this->stopwatch->getEvent($section));

And here is the result:

I read 500000 rows from the JSON File data/movies-500000.json
default/read_json_file: 8.00 MiB - 17976 ms

Yes, we parsed our 500k JSON records in 20 seconds and using only 8MB!

We can't predict how big the file to integrate will be in some cases. Using a streaming approach will make your code more robust, fast, memory-efficient, and future-proof.

Download the Code and Examples​

You can find all the code and examples in this GitHub repository.

It's packaged as a simple Symfony project, a set of commands, it also comes with a Docker image. 🐋

In this tutorial, we will learn how to read and write XLSX files in PHP with the help of examples.

Last but not least, we'll parse an Excel file of 1 million lines in PHP in a very fast and memory-efficient manner.

The whole code and examples are available in a GitHub repository; it comes packaged as a simple Symfony project and provides a Docker image.

Best PHP Libraries to Parse and Write Excel Files​

Several libraries allow to work with Excel files; they come with their pros and cons.

The most famous is phpoffice/phpspreadsheet; it has more than 10k stars on GitHub. This library allows reading, creating, and writing spreadsheet documents in PHP. This library was formerly named phpoffice/phpexcel, the project has been deprecated in 2017, and phpspreadsheet officially replaced phpexcel.

The challenger is box/spout; it has more than 4k stars on GitHub. This library allows reading and writing spreadsheet files in a fast and scalable way.

There is no debate regarding the support of different file formats: phpoffice/phpspreadsheet supports far more formats, especially the oldest ones which are very convenient when you need to parse XLS files created with Excel 2003 97, or 95.

When it comes to performance, the big difference is that phpoffice/phpspreadsheet loads the whole XML document in memory while box/spout streams the Excel document's parsing, allowing it to consume very little memory.

Which PHP Excel Library should you use?

There are other libraries, but they don't bring anything more or very different.

Both phpspreadsheet and spout also cover the classic operations of reading and writing CSV files in PHP.

Install Box/Spout library​

Let's start by installing box/spout library.

composer require box/spout

It provides a simple code API to read or create spreadsheets. Its main advantage is to manipulate large files in a memory-efficient manner.

Excel (XLSX) File Example​

We'll use an XLSX file with a single tab containing tabular data about movies in the following example.

Read an Excel File (XLSX)​

We parse our existing XLSX file:

1. Create the Excel Reader using ReaderEntityFactory::createXLSXReader()
2. Open the XSLX file with $reader->open($path)
3. Browse each Sheet of the spreadsheet with $reader->getSheetIterator()
4. Browse each Row of the Sheet with $sheet->getRowIterator()
5. Browse each Cell of the Row with $row->getCells()
6. Access each Value of the Cell with $cell->getValue()
7. Close the Excel Reader (and the File) with $reader->close()

use Box\Spout\Reader\Common\Creator\ReaderEntityFactory;

$path = 'data/movies-100.xlsx';
# open the file
$reader = ReaderEntityFactory::createXLSXReader();
$reader->open($path);
# read each cell of each row of each sheet
foreach ($reader->getSheetIterator() as $sheet) {
    foreach ($sheet->getRowIterator() as $row) {
        foreach ($row->getCells() as $cell) {
            var_dump($cell->getValue());
        }
    }
}
$reader->close();

We can use this snippet to import Excel rows into a database. In that case, we'd need to insert or update data for each parsed row.

Write an Excel File (XLSX)​

We write in an XLSX file:

1. Create the Excel Writer using WriterEntityFactory::createXLSXWriter()
2. Open the XSLX file with $writer->open($path) that will allow to create the Excel file
3. Iterate over the rows we want to insert
4. Create each Excel row with WriterEntityFactory::createRowFromArray($row)
5. Insert each row in Excel with $writer->addRow($rowFromValues);
6. Close the Excel Writer (and the File) with $writer->close()

use Box\Spout\Writer\Common\Creator\WriterEntityFactory;

$rows = [
    ['id', 'title', 'poster', 'overview', 'release_date', 'genres'],
    [181808, "Star Wars: The Last Jedi", "https://image.tmdb.org/t/p/w500/kOVEVeg59E0wsnXmF9nrh6OmWII.jpg", "Rey develops her newly discovered abilities with the guidance of Luke Skywalker, who is unsettled by the strength of her powers. Meanwhile, the Resistance prepares to do battle with the First Order.", 1513123200, "Documentary"],
    [383498, "Deadpool 2", "https://image.tmdb.org/t/p/w500/to0spRl1CMDvyUbOnbb4fTk3VAd.jpg", "Wisecracking mercenary Deadpool battles the evil and powerful Cable and other bad guys to save a boy's life.", 1526346000, "Action, Comedy, Adventure"],
    [157336, "Interstellar", "https://image.tmdb.org/t/p/w500/gEU2QniE6E77NI6lCU6MxlNBvIx.jpg", "Interstellar chronicles the adventures of a group of explorers who make use of a newly discovered wormhole to surpass the limitations on human space travel and conquer the vast distances involved in an interstellar voyage.",1415145600,"Adventure, Drama, Science Fiction"]
];
$path = 'data/new-file.xlsx';
$writer = WriterEntityFactory::createXLSXWriter();
$writer->openToFile($path);
foreach ($rows as $row) {
    $rowFromValues = WriterEntityFactory::createRowFromArray($row);
    $writer->addRow($rowFromValues);
}
$writer->close();

We can use this snippet to export data to Excel. For instance, by reading rows from a database table to write each row in the XLSX file.

Besides Microsoft Excel, Google Sheets is getting a lot of traction from users who need to collaborate near real-time on business data. Google offers API to create, read and update Google Sheets data using PHP.

Read a Large Excel File Efficiently while Using Low Memory​

A common issue while manipulating large files is memory consumption and reading or writing efficiency.

The great news is that Spout takes this challenge into account and allows browsing the file content without loading everything in memory.

Let's take an example of an xlsx file containing 1M of lines; this file weights 200MB.

-rw-rw-rw- 1 nico nico 205M mars 12 10:10 data/movies-1000000.xlsx

Let's load all its content:

// I'm using here the Symfony Console & StopWatch components
$section = 'read_excel_file';
$this->stopwatch->start($section);
$path = 'data/movies-1000000.xlsx';
$reader = ReaderEntityFactory::createXLSXReader();
$reader->open($path);
# read each cell of each row of each sheet
foreach ($reader->getSheetIterator() as $sheet) {
    foreach ($sheet->getRowIterator() as $row) {
        $cells = $row->getCells();
        foreach ($cells as $cell) {
            // we do nothing, but we want to ensure we browse each cell
        }
    }
}
$this->stopwatch->stop($section);
$output->writeln("I read 1.000.000 rows from the Excel File ".$path);
$output->writeln((string) $this->stopwatch->getEvent($section));

And here is the result:

I read 1.000.000 rows from the Excel File data/movies-1000000.xlsx
default/read_excel_file: 8.00 MiB - 104666 ms

We load our 1M lines using only 8MB of memory (I'm using PHP8).

When streaming the data reading and processing, you can apply rich transformations while keeping the memory usage low and a fast execution time.

Download the Code and Examples​

You can find all the code and examples in this GitHub repository.

It's packaged as a simple Symfony project, a set of commands, it also comes with a Docker image. 🐋

In this tutorial, we will learn how to read and write CSV files in PHP with the help of examples.

We'll also explore how to perform the most common manipulation such as filtering, sorting, and transforming the data.

Last but not least, we'll learn how to parse a CSV file of 1 million lines in PHP in a fast and memory-efficient manner.

I used PHP8 while coding and testing the examples:

• The examples with native functions are compatible with very old PHP versions.
• The examples using league/csv require a PHP7 version as a minimum.
• The whole code and examples are available in a GitHub repository; it comes packaged as a simple Symfony project and provides a Docker image.

Our Example of CSV File​

We'll use a CSV file containing data about movies in this tutorial.

Here is a sample of this data set in plain text:

id,title,poster,overview,release_date,genres
181808,"Star Wars: The Last Jedi",https://.../mWII.jpg,"Rey develops her newly discovered abilities with the guidance of Luke Skywalker, [...]",1513123200,"Documentary"
383498,"Deadpool 2",https://.../3VAd.jpg,"Wisecracking mercenary Deadpool battles the evil and powerful Cable and other bad[...]",1526346000,"Action, Comedy, Adventure"
157336,"Interstellar",https://.../BvIx.jpg,"Interstellar chronicles the adventures of a group of explorers who make use of a [...]",1415145600,"Adventure, Drama, Science Fiction"

Usually, in the CSV format:

1. The first line contains the headers
2. Each following line is a data row
3. A comma separates each cell in a row
4. A double-quote encapsulate cells containing text

Sometimes, we can find different characters to separate the data, encapsulate strings, or escape special characters.

Let's look at our sample file in a tabular way:

Read and Write CSV Files (Old-Fashioned Way)​

Read a CSV File Using fgetcsv​

The steps to read a CSV file in PHP with native functions:

1. Open the file with fopen using the read mode
2. Parse the CSV rows from the file with fgetcsv
3. Close the file with fclose

$path = 'data/movies-100.csv';
$handle = fopen($path, "r"); // open in readonly mode
while (($row = fgetcsv($handle)) !== false) {
    var_dump($row);
}
fclose($handle);

It loads each row as an array; the first row contains the headers.

// the headers
array(6) {
  [0]=>
  string(2) "id"
  [1]=>
  string(5) "title"
  [2]=>
  string(6) "poster"
  [3]=>
  string(8) "overview"
  [4]=>
  string(12) "release_date"
  [5]=>
  string(6) "genres"
}
// another row
array(6) {
  [0]=>
  string(3) "807"
  [1]=>
  string(5) "Se7en"
  [2]=>
  string(63) "https://image.tmdb.org/t/p/w500/6yoghtyTpznpBik8EngEmJskVUO.jpg"
  [3]=>
  string(390) "Two homicide detectives are on a desperate hunt for a serial killer whose crimes are based on the 'seven deadly sins' in this dark and haunting film that takes viewers from the tortured remains of one victim to the next. The seasoned Det. Sommerset researches each sin in an effort to get inside the killer's mind, while his novice partner, Mills, scoffs at his efforts to unravel the case."
  [4]=>
  string(9) "811731600"
  [5]=>
  string(24) "Crime, Mystery, Thriller"
}

In some cases, we want to manipulate rows independently, let's transform each CSV row into an associative array:

// Parse the rows
$rows = [];
$handle = fopen($path, "r");
while (($row = fgetcsv($handle)) !== false) {
    $rows[] = $row;
}
fclose($handle);
// Remove the first one that contains headers
$headers = array_shift($rows);
// Combine the headers with each following row
$array = [];
foreach ($rows as $row) {
    $array[] = array_combine($headers, $row);
}
var_dump($array);

We now have each row as an associative array, with headers as indexes of each array. We can manipulate the rows independently as simple JSON objects.

array(100) {
  [0]=>
  array(6) {
    ["id"]=>
    string(6) "287947"
    ["title"]=>
    string(7) "Shazam!"
    ["poster"]=>
    string(63) "https://image.tmdb.org/t/p/w500/xnopI5Xtky18MPhK40cZAGAOVeV.jpg"
    ["overview"]=>
    string(98) "A boy is given the ability to become an adult superhero in times of need with a single magic word."
    ["release_date"]=>
    string(10) "1553299200"
    ["genres"]=>
    string(23) "Action, Comedy, Fantasy"
  }
  // more rows

Write a CSV File Using fputcsv​

The steps to create a CSV file in PHP with native functions:

1. Open the file with fopen using the write mode
2. Write each array in a CSV row with fputcsv
3. Close the file with fclose

$rows = [
    ['id', 'title', 'poster', 'overview', 'release_date', 'genres'],
    [181808, "Star Wars: The Last Jedi", "https://image.tmdb.org/t/p/w500/kOVEVeg59E0wsnXmF9nrh6OmWII.jpg", "Rey develops her newly discovered abilities with the guidance of Luke Skywalker, who is unsettled by the strength of her powers. Meanwhile, the Resistance prepares to do battle with the First Order.", 1513123200, "Documentary"],
    [383498, "Deadpool 2", "https://image.tmdb.org/t/p/w500/to0spRl1CMDvyUbOnbb4fTk3VAd.jpg", "Wisecracking mercenary Deadpool battles the evil and powerful Cable and other bad guys to save a boy's life.", 1526346000, "Action, Comedy, Adventure"],
    [157336, "Interstellar", "https://image.tmdb.org/t/p/w500/gEU2QniE6E77NI6lCU6MxlNBvIx.jpg", "Interstellar chronicles the adventures of a group of explorers who make use of a newly discovered wormhole to surpass the limitations on human space travel and conquer the vast distances involved in an interstellar voyage.",1415145600,"Adventure, Drama, Science Fiction"]
];
$path = 'data/new-file.csv';
$fp = fopen($path, 'w'); // open in write only mode (write at the start of the file)
foreach ($rows as $row) {
    fputcsv($fp, $row);
}
fclose($fp);

The default separator is the comma, we can specify different parameters such as separator, enclosure, escape and eol when using fgetcsv and fputcsv functions.

Append New Rows in a CSV File Using fputcsv​

Let's append rows at the end of an existing file:

$rows = [
    ['id', 'title', 'poster', 'overview', 'release_date', 'genres'],
    [181808, "Star Wars: The Last Jedi", "https://image.tmdb.org/t/p/w500/kOVEVeg59E0wsnXmF9nrh6OmWII.jpg", "Rey develops her newly discovered abilities with the guidance of Luke Skywalker, who is unsettled by the strength of her powers. Meanwhile, the Resistance prepares to do battle with the First Order.", 1513123200, "Documentary"],
    [383498, "Deadpool 2", "https://image.tmdb.org/t/p/w500/to0spRl1CMDvyUbOnbb4fTk3VAd.jpg", "Wisecracking mercenary Deadpool battles the evil and powerful Cable and other bad guys to save a boy's life.", 1526346000, "Action, Comedy, Adventure"],
    [157336, "Interstellar", "https://image.tmdb.org/t/p/w500/gEU2QniE6E77NI6lCU6MxlNBvIx.jpg", "Interstellar chronicles the adventures of a group of explorers who make use of a newly discovered wormhole to surpass the limitations on human space travel and conquer the vast distances involved in an interstellar voyage.",1415145600,"Adventure, Drama, Science Fiction"]
];
$path = 'data/new-file.csv';
$fp = fopen($path, 'a'); // open in write only mode (with pointer at the end of the file)
foreach ($rows as $row) {
    fputcsv($fp, $row);
}
fclose($fp);

The essential piece is to understand the mode parameter used in the fopen function:

• r is a read-only mode
• w is a write-only mode, starting at the beginning of the file (erase an existing file)
• w+ is a read/write mode, starting at the beginning of the file (erase an existing file)
• a is a write-only mode, starting at the end of the file (append content at the end of the file)
• a+ is a read/write mode, starting at the end of the file (append content at the end of the file)

Using the modes w, w+, a, a+ will create the CSV file if it does not exist yet.

Read and Write CSV Files (Modern Way)​

This previous reading and writing approach is totally fine, but some modern libraries can make our lives easier and our code a bit more readable.

This tutorial uses the excellent league/csv library, which provides a clean and straightforward CSV manipulation API.

We can also note the great box/spout library, which is very strong too, offers support for other formats and can be used to read and write Excel files in PHP.

Install league/csv​

Let's install the league/csv library by using the composer package manager:

composer require league/csv

Read a CSV File Using League\Csv\Reader​

Read CSV rows from a file using theReader:

use League\Csv\Reader;
$path = 'data/movies-100.csv';
$csv = Reader::createFromPath($path, 'r');
$csv->setHeaderOffset(0); // use the first line as headers for rows

$header = $csv->getHeader();
var_dump($header);

$rows = $csv->getRecords();
foreach ($rows as $row) {
    var_dump($row);
}

When using the setHeaderOffset configuration, we can see a slight but interesting difference compared with the use of native PHP function. The league/csv reader loads the rows as associative arrays (JSON object). It makes data manipulation easier as we can deal independently with each row.

array(6) {
  ["id"]=>
  string(3) "807"
  ["title"]=>
  string(5) "Se7en"
  ["poster"]=>
  string(63) "https://image.tmdb.org/t/p/w500/6yoghtyTpznpBik8EngEmJskVUO.jpg"
  ["overview"]=>
  string(390) "Two homicide detectives are on a desperate hunt for a serial killer whose crimes are based on the 'seven deadly sins' in this dark and haunting film that takes viewers from the tortured remains of one victim to the next. The seasoned Det. Sommerset researches each sin in an effort to get inside the killer's mind, while his novice partner, Mills, scoffs at his efforts to unravel the case."
  ["release_date"]=>
  string(9) "811731600"
  ["genres"]=>
  string(24) "Crime, Mystery, Thriller"
}

Write a CSV File Using League\Csv\Writer​

Write CSV rows into a file using theWriter:

use League\Csv\Writer;
$rows = [
    ['id', 'title', 'poster', 'overview', 'release_date', 'genres'],
    [181808, "Star Wars: The Last Jedi", "https://image.tmdb.org/t/p/w500/kOVEVeg59E0wsnXmF9nrh6OmWII.jpg", "Rey develops her newly discovered abilities with the guidance of Luke Skywalker, who is unsettled by the strength of her powers. Meanwhile, the Resistance prepares to do battle with the First Order.", 1513123200, "Documentary"],
    [383498, "Deadpool 2", "https://image.tmdb.org/t/p/w500/to0spRl1CMDvyUbOnbb4fTk3VAd.jpg", "Wisecracking mercenary Deadpool battles the evil and powerful Cable and other bad guys to save a boy's life.", 1526346000, "Action, Comedy, Adventure"],
    [157336, "Interstellar", "https://image.tmdb.org/t/p/w500/gEU2QniE6E77NI6lCU6MxlNBvIx.jpg", "Interstellar chronicles the adventures of a group of explorers who make use of a newly discovered wormhole to surpass the limitations on human space travel and conquer the vast distances involved in an interstellar voyage.",1415145600,"Adventure, Drama, Science Fiction"]
];

$path = 'data/new-file2.csv';
$csv = Writer::createFromPath($path, 'w');
$csv->insertAll($rows);

This code snippet is an interesting one to export your database in a CSV file; in this case, you need to feed the file by reading rows from your database using some queries.

Let's keep in mind that when we use createFromPath with the mode w, we erase the entire file content if it already exists.

Append New Rows in a CSV File Using League\Csv\Writer​

Sometimes, we need to append lines at the end of an existing file without erasing its current content.

In this case, we open the file by using the value a+ for the open_mode parameter:

use League\Csv\Writer;
$appendRows = [
    [324857, "Spider-Man: Into the Spider-Verse", "https://image.tmdb.org/t/p/w500/iiZZdoQBEYBv6id8su7ImL0oCbD.jpg", "Miles Morales is juggling his life between being a high school student and being a spider-man. When Wilson 'Kingpin' Fisk uses a super collider, others from across the Spider-Verse are transported to this dimension.",1544140800,"Action, Adventure, Animation, Science Fiction, Comedy"],
    [456740, "Hellboy", "https://image.tmdb.org/t/p/w500/bk8LyaMqUtaQ9hUShuvFznQYQKR.jpg", "Hellboy comes to England, where he must defeat Nimue, Merlin's consort and the Blood Queen. But their battle will bring about the end of the world, a fate he desperately tries to turn away.",1554944400,"Fantasy, Action"]
];
$path = 'data/new-file2.csv';
$csv = Writer::createFromPath($path, 'a+');
$csv->insertAll($appendRows);

Advanced Tips & Tricks Using League\Csv​

Now, we'll explore advanced yet commonly used operations on CSV.

Count the CSV Rows​

use League\Csv\Reader;
$csv = Reader::createFromPath($path, 'r');
$csv->setHeaderOffset(0);
var_dump($csv->count());

Return the CSV Headers​

use League\Csv\Reader;
$csv = Reader::createFromPath($path, 'r');
$csv->setHeaderOffset(0);
var_dump($csv->getHeader());

array(6) {
  [0]=>
  string(2) "id"
  [1]=>
  string(5) "title"
  [2]=>
  string(6) "poster"
  [3]=>
  string(8) "overview"
  [4]=>
  string(12) "release_date"
  [5]=>
  string(6) "genres"
}

Fetch One CSV Row by Using its Index​

We fetch the 10th row of the file:

use League\Csv\Reader;
$csv = Reader::createFromPath($path, 'r');
$csv->setHeaderOffset(0);
var_dump($csv->fetchOne(10));

array(6) {
  ["id"]=>
  string(3) "920"
  ["title"]=>
  string(4) "Cars"
  ["poster"]=>
  string(63) "https://image.tmdb.org/t/p/w500/qa6HCwP4Z15l3hpsASz3auugEW6.jpg"
  ["overview"]=>
  string(386) "Lightning McQueen, a hotshot rookie race car driven to succeed, discovers that life is about the journey, not the finish line, when he finds himself unexpectedly detoured in the sleepy Route 66 town of Radiator Springs. On route across the country to the big Piston Cup Championship in California to compete against two seasoned pros, McQueen gets to know the town's offbeat characters."
  ["release_date"]=>
  string(10) "1149728400"
  ["genres"]=>
  string(36) "Animation, Adventure, Comedy, Family"
}

Fetch Many CSV Rows by Using Offset and Limit​

We fetch 3 rows starting from the 10th row:

use League\Csv\Reader;
use League\Csv\Statement;
$csv = Reader::createFromPath($path, 'r');
$csv->setHeaderOffset(0);
$stmt = Statement::create()
    ->offset(10)
    ->limit(3);
$records = $stmt->process($csv);
foreach ($records as $row) {
    var_dump($row);
}

Filter CSV Rows Based on a Condition​

We fetch only the movies where the title contains "Deadpool":

use League\Csv\Reader;
use League\Csv\Statement;
$csv = Reader::createFromPath($path, 'r');
$csv->setHeaderOffset(0);
$stmt = Statement::create()
    ->where(function($row) { return strpos($row['title'], 'Deadpool') !== false; });
$records = $stmt->process($csv);
foreach ($records as $row) {
    var_dump($row);
}

array(6) {
  ["id"]=>
  string(6) "383498"
  ["title"]=>
  string(10) "Deadpool 2"
  ["poster"]=>
  string(63) "https://image.tmdb.org/t/p/w500/to0spRl1CMDvyUbOnbb4fTk3VAd.jpg"
  ["overview"]=>
  string(108) "Wisecracking mercenary Deadpool battles the evil and powerful Cable and other bad guys to save a boy's life."
  ["release_date"]=>
  string(10) "1526346000"
  ["genres"]=>
  string(25) "Action, Comedy, Adventure"
}
array(6) {
  ["id"]=>
  string(6) "293660"
  ["title"]=>
  string(8) "Deadpool"
  ["poster"]=>
  string(63) "https://image.tmdb.org/t/p/w500/yGSxMiF0cYuAiyuve5DA6bnWEOI.jpg"
  ["overview"]=>
  string(348) "Deadpool tells the origin story of former Special Forces operative turned mercenary Wade Wilson, who after being subjected to a rogue experiment that leaves him with accelerated healing powers, adopts the alter ego Deadpool. Armed with his new abilities and a dark, twisted sense of humor, Deadpool hunts down the man who nearly destroyed his life."
  ["release_date"]=>
  string(10) "1454976000"
  ["genres"]=>
  string(25) "Action, Adventure, Comedy"
}

Sort the CSV Rows Based on a Condition​

We fetch the five first movies ordered by ascendant alphabetical title:

use League\Csv\Reader;
use League\Csv\Statement;
$csv = Reader::createFromPath($path, 'r');
$csv->setHeaderOffset(0);
$stmt = Statement::create()
    ->orderBy(function($row1, $row2) { return strcmp($row1['title'], $row2['title']); })
    ->limit(5);
$records = $stmt->process($csv);
foreach ($records as $row) {
    var_dump($row);
}

Convert CSV to JSON​

Parsing a CSV file and converting its rows to a JSON string is a pretty straightforward operation:

use League\Csv\Reader;
$csv = Reader::createFromPath($path, 'r');
// use the first line as header for rows
$csv->setHeaderOffset(0);
// get all the rows as an array of associative arrays
$data = $csv->jsonSerialize();
// encode the array to a json string
$jsonString = json_encode($data, JSON_PRETTY_PRINT);

Convert JSON to CSV​

Converting a JSON format to a CSV file requires a bit more work; we first need to extract the keys from one of the JSON objects to use them as the headers of our CSV file:

use League\Csv\Writer;

$path = 'data/movies-flat-10.json';
// read the file's content as a string
$jsonString = file_get_contents($path);
// convert the json string to an array of associative arrays (one per object)
$jsonObjects = json_decode($jsonString, true);

// fetch the keys of the first json object
$headers = array_keys(current($jsonObjects));

// flatten the json objects to keep only the values as arrays
$rows = [];
foreach ($jsonObjects as $jsonObject) {
    $rows[] = array_values($jsonObject);
}

// insert the headers and the rows in the CSV file
$path = 'data/new-file2.csv';
$csv = Writer::createFromPath($path, 'w');
$csv->insertOne($headers);
$csv->insertAll($rows);

If you want to go further on JSON files manipulation, you can look at this dedicated post on reading and writing JSON files using PHP.

Read a Big CSV File While Using a Minimum of Memory​

The trick to parse big CSV files by keeping a low memory usage is to never load all data in memory.

Luckily, both native and league/csv reading methods allow us to iterate and stream the content.

Let's take an example of a file containing 1M of lines; this file weights almost 400MB.

-rw-r--r-- 1 nico nico 393M may 13 12:38 data/movies-1000000.csv

Let's load all its content:

// I'm using here the Symfony Console & StopWatch components
use Symfony\Component\Stopwatch\Stopwatch;
use League\Csv\Reader;
$section = 'read_csv_file';
$this->stopwatch->start($section);
$path = 'data/movies-1000000.csv';
$csv = Reader::createFromPath($path, 'r');
$csv->setHeaderOffset(0);
$rows = $csv->getRecords();
foreach ($rows as $row) {
    // we do nothing, but we want to ensure we browse each row
}
$this->stopwatch->stop($section);
$output->writeln("I read ".$csv->count()." rows from the CSV File ".$path);
$output->writeln((string) $this->stopwatch->getEvent($section));

And here is the result:

I read 1000000 rows from the CSV File data/movies-1000000.csv
default/read_csv_file: 6.00 MiB - 26699 ms

We load our 1 million CSV lines in 26 seconds by using only 6MB of memory! 🤯

By streaming properly the data reading and the processing you want to apply, you can keep the memory usage very low.

Using this method, we can write a very efficient PHP CSV parser which is especially beneficial when importing a large CSV file into a database.

Download the Code and Examples​

You can find all the code and examples in this GitHub repository.

It's packaged as a simple Symfony project, a set of commands, it also comes with a Docker image. 🐋

I found many shared struggles while mentoring them; that's why I'm writing a series on how to prepare to move into these positions.

What is an Engineering Manager?​

An Engineering Manager (EM) is the hierarchical manager of a team of software engineers. This position tends to appear when the engineering team gathers 10+ engineers.

The Engineering Manager's mission is to lead and support software engineers to maximize their positive impact on the expected business outcomes.

Career Path​

The Engineering Manager position is usually the first level in the people manager track of the engineering career ladder.

Moving into engineering management is usually a difficult transition to achieve. It requires a critical shift in your focus, moving it from technical leadership to people leadership. People management activities are becoming the most crucial part of your responsibilities.

On this career path, the next levels are the positions of Engineering Director and VP of Engineering.

How to Become an Engineering Manager?​

Progressing into engineering management requires prior experience in team leadership, for instance, by acting as a team lead or as a lead developer. This first experience will allow you to train your muscles on animating the delivery of a team, communicating efficiently, and getting more comfortable on project management practices.

If you want to become an engineering manager, you can prepare yourself for this transition by working on the following aspects.

Leadership​

One critical aspect of your mission is to lead a team of engineers.

We can question ourselves about the differences and the dependencies between leadership and management. Grace Hopper had an interesting point of view on this question: "You manage things; you lead people."

Leading a team is about inspiring the teammates to collaborate to achieve common goals that create positive business outcomes.

Alignment with the Business Goals​

To prepare a shift in engineering management, you need to get a strong understanding of the business goals of your organization. Train yourself to articulate how the team's current project contributes to the success of the company. Train yourself to pitch how this project will make your customers successful.

Doing this kind of exercise is an excellent preparation to align the team efforts with a broader intent and related strategy. It helps to create a clear purpose and to share a common understanding of why we do things.

Make the Team and Individuals Successful​

Work on understanding how to help each teammate learning new skills, becoming better at his craft to increase his impact. There are plenty of opportunities to strengthen your mentoring skills. The most efficient exercise is to help your teammates. It's also a matter of posture, always being ready and available to help.

Try to understand the team's dynamics and how we collaborate as a team. Who is comfortable with what, could we be more efficient by working differently?

Master the Work Organisation and Processes​

The engineering manager's job is also about leveraging teamwork and making the collaboration smoother.

Get interested in your organization framework, what's our goal-setting structure, how these goals are tied back to our work practices. What are your team's project management and engineering practices? Do you do continuous integration and continuous deployment? What is our software development life cycle? How do we balance build, support, and maintenance?

Working efficiently together requires some shared and well-understood practices, you'll need to master these to move into engineering management.

Leverage Strong Communication Practices​

The foundation of efficient teamwork is efficient communication.

A successful engineering manager fosters excellent communication between the team members and with the other teams. To enable excellent communication, you need to draw what are the dependencies between teams. What are the teams' goals and projects, how are they connected? Who needs to know what and when?

Nurturing solid communication practices is a complex challenge. A rock-solid communication system can quickly become inefficient or outdated. Communication highly depends on the context, and as the context continuously evolves, the framework has to be regularly adapted.

The Choice of a New Career​

Becoming an engineering manager is a vibrant but hard journey. It requires shifting your attention to different aspects, moving your focus from the technical leadership to the people leadership. It's about starting a brand new career and training different muscles.

I found many shared struggles while mentoring them; that's why I'm writing a series on how to get prepared to move into these positions.

What is a Lead Developer?​

A Lead Developer is the technical leader of a team of developers. She's in charge of the success of a project. She animates the delivery to build the right things, the right way, and on time.

She is responsible for advocating on best practices, communicating on the progress, mentoring other developers, providing technical guidance to the team, and deciding on technical trade-offs.

Depending on the organization, we can refer to a lead developer as a lead engineer, a team lead, a technical project manager, or a tech lead.

Career Path​

In an engineering career ladder, the lead developer position often sits between the individual contributor track and the people manager track.

It's not an engineering manager position as engineering management includes people management responsibilities. However, moving into a lead developer position is a solid first step in engineering management.

Moving into a lead developer role is also a significant progression in the technical leadership track. It's an excellent way to get prepared to become a software architect, a staff engineer, or a principal engineer.

This role opens a lot of opportunities.

Become a Lead Developer?​

If you want to become a lead developer, a critical aspect to consider is the shift of responsibilities.

A lead dev is responsible for the result of a team on a project. It's not anymore about your own technical excellence, or what you individually build or contribute to building. It's now about the success of the development team. Let's discuss the main areas to work on to be prepared to move to a lead developer position.

Technical guidance​

You can usually pretend to become a lead developer after a few years of experience as a developer or software engineer. These first years are critical to consolidate your technical skills and learn to be autonomous in your developments.

You start to have a solid sense of how to build things to answer the business needs, and you did it with success on several projects.

A useful exercise is to discover how to articulate larger pieces of software. You need to understand the technical decisions and the trade-offs regarding a given architecture. You can muscle your tech decision-making by reviewing existing projects and chatting with current tech leaders on how and why we build this way.

Be a role model​

As for any leadership position, it's critical to embody the excellence and the behavior that your organization expects for developers.

If you lead a team of developers, you become their representative, and they deserve to be well represented. To become a lead developer, you need to become first a great developer.

Work organization​

A critical success factor is how the team collaborates.

Get interested in project management practices. How to prepare the work? How to slice the tasks? How to measure and communicate on the progress?

Get interested in each other skills. Who is comfortable doing what? What your teammates like or not like? What do they want to learn?

Any teamwork requires some upfront preparation and a proper animation to collaborate efficiently. Ask if you can contribute in a way or another in these aspects. Your tech lead or manager should be happy to delegate you some parts of it, and it will be an enjoyable exercise to train your leadership muscle.

Be a mentor​

A lead developer contributes actively in helping her teammates to learn, to become better software engineers.

There are plenty of opportunities to strengthen your mentoring skills. You can improve by explaining an intricate part of the tech stack. You can also help to onboard a new developer on the team. You can mentor a junior developer or an intern.

The most important aspect is to have the proper attitude: be always willing to help. You can evaluate your progress by how often your teammates are coming to you to ask for your help or work with you.

Communication​

The foundation of efficient teamwork is efficient communication. As a team, we need a shared understanding: why we do things, what's our mission, what our goals are.

Frictions, duplicate work, or a waste of effort often come from a few misunderstandings between team members. To mitigate this inherent challenge, you'll need to work on your communication skills.

You can improve by training yourself to be crystal clear when communicating. Listen carefully, ask genuine questions to ensure you understand correctly, re-phrase with your own words. Adapt your message to the audience's knowledge and domain of expertise.

Contribute to helping the team communicate well, document the significant changes, and amplify the essential pieces of information.

Earn Trust​

Last but not least, to move to a lead developer position, you will need to earn your teammates' and manager' trust.

We build trust by our actions and our behavior, by being consistent, by being reliable, by helping others.

A lot of small and concrete actions will contribute to building the strong grounds, the foundations of the team's trust. And if you want to become a lead developer, you can start making these actions right now.

The architecture decision record (ADR) is a formalized document that captures and explains this design choice and its impacts.

It comes with an engineering process describing how to make these decisions and record them.

Why using ADR?​

When working on a large software codebase, it may be hard to know why the architecture has been designed this way in the first place.

The project's context is evolving. We handle more functional use cases, more data, more users, the architecture looks irrelevant or limited. The teams are changing; new engineers joined, some elders left. Can we change this aspect of the architecture? What are the impacts?

ADR is a robust documentation foundation allowing your team to share and understand the former technical decisions. It also supports the team's alignment on how the current architecture should evolve to answer tomorrow's needs.

How to deploy ADR in your organization?​

You can deploy architecture decision records by establishing a four-step workflow: identify the decisions, make the decisions, document the decisions, and share them.

1. Identify​

Define what kind of architecture decisions should follow your ADR process. Usually, we're talking here of a large change impacting the whole architecture: replace the storage system, introducing a new language or a new framework, integrate a new technical component, etc

Explain to the team how to identify a potential decision. As well as how the decision will be made and how to record and track its resolution.

2. Make the Decision​

Describe the current context, the limitations, the potential changes, the pros/cons, the expected benefits, and impact. You should use a template to articulate the pieces of information that need to be collected to make the decision. Involve the group of people to make the decision.

3. Document​

Record the decision in your architecture decision records repository. This space has to be known by all the teammates and has to be up to date.

4. Share​

Ensure the decision is known and understood by the engineering team and by the groups impacted by this decision. The ADR should be self-explanatory to understand the reasoning behind the architecture decision.

We didn't talk for a while, and I hope you're doing well.

You're getting older, like me. I remind the good memories we have together. Like when I learned new tricks or new patterns with you.

We also had some more difficult times, like these memory leaks that took ages to fix (should I say hacked?). We grew together. And sometimes, growing is a painful experience.

As Virginia Woolf said, "Growing up is losing some illusions, in order to acquire others.". I've sometimes been unfair with you, and I apologize.

I've been rude, yelling to you, complaining about your poor design, or readability, when I was responsible for it.

It's true, sometimes I cut a bit too many corners, but most of the time, I was doing my very best to make you right and clean.

Requirements change, expectations too, and what was good enough in the former context, was not good enough at scale. And especially because we had great successes together. More customers, more users, more data, more scenarios to cover.

You always delivered value to our users, simplifying their day to day work, answering their pains. You also created a lot of value to our business, making it sustainable, allowing us to reach even more customers.

In our industry, legacy often takes a negative meaning. We commonly use legacy as a synonym for deprecated, too old, or painful. Legacy is also our heritage, our inheritance, with all the positive aspects. The business and technical learnings, the value we create, the problems we solve.

Don't worry. The brand new code we write today will be legacy tomorrow, literally. There are only two ways for this code to not becoming our legacy. It would mean this new code will not be used or useable in production. The other option is that we'll don't learn anything and that it would look as good as today in a few months. It will not happen.

Dear legacy code, I love you. You're reliable (most of the time). You create value; you made us and our customers successful. We learned and grew together. You're an invaluable asset.

We'll continue to improve you, to take care of you, to rewrite some parts to match our growing needs, to remove some parts making you simpler, cleaner and more readable.

Yours faithfully, Nicolas

It's a natural tendency. We tend to talk first and more about solutions rather than discussing the underlying problem.

A simple practice to reframe the discussion is to ask Why. Ask it genuinely to grasp what problem we're discussing. To understand what we're trying to solve.

In the early 20th century, Sakichi Toyoda, an inventor working for Toyota, developed a root cause analysis concept. Known as Five Whys, the aim is to detect the root cause of a defect, by iteratively asking Why. In most of the cases, five iterations are enough to reach the root cause.

Since then, the Lean methodologies evangelized the use of this practice. Especially for problem-solving and for improving processes.

I find it very efficient when applied to product management.

First, to avoid to stick with our former solution. We tend to fall in love with a solution quickly. It allows us to step back and to discuss the problem.

Then, it prevents the second trap of staying at the surface of a problem.

We need to dig into the issue, persevering, checking data points, iterating to discover the root cause. Depending on the problem, it may be tricky to separate the causes and the symptoms.

Once we have a good grasp of the problem, we can look for patterns. Does this problem is an industry problem? Does it concern several customers? What is the opportunity? What are the potential outcomes of solving it?

Finally, we can go back thinking about potential solutions and figuring out the different possibilities; and their pros and cons.

In our organizations, we can mix the activities of studying a problem and defining a solution. When doing so, we reinforce the attachment to our former solution and don't give to the problem the time it deserves.

We should fall in love with the problem, not with the solution.

Some practices or processes can support the split of these activities. For instance, write a one-pager talking only about the problem. And then, discussing the potential solutions into a dedicated one-pager.

I'm talking here about pretty big problems. The fine-tuning of an existing solution does not deserve so much effort. We get new learning or data points from the usage of this solution. In this case, small improvements are more a matter of increasing the adoption by enhancing the user experience, or by covering a new scenario.

A product organization will never be able to answer all the problems its users are facing. We work into a constrained system; we need to invest our efforts in solving the right problem with a relevant solution.

Our customers, our teams, our businesses (and our products) deserve it.

It's now time to go back digging into problems. ⛏️

I tend to see a product backlog as a small garden. As a product manager, you need to take care of your garden. To nurture it regularly, to remove weeds, to grow promising seeds into nourishing plants.

Here are a few thoughts and practices on backlog gardening.

The product backlog must be clear. It reveals an intention, what you want to achieve to solve a user pain point. A teammate should understand it in one blink.

Have you ever heard about "code smells"? The negative feeling you have, as a software engineer when you look at a codebase or piece of code.

Your gut feeling tells you something is wrong. But you need to dig a bit to understand what makes you uncomfortable. The same applies to a product backlog.

Huge backlog, hundreds of items, a patchwork of intentions, not well organized, no clear prioritization.

On the backlog size, more than a few dozen of user stories create a too big cognitive load. When working on one large product or several products, create several backlogs will help.

Camille F., product director in our team, has an excellent practice of naming a backlog with the expected goal. For instance, "Boost the adoption of YouNameIt".

Using an explicit name creates a strong shared understanding with the team, reminding why we're doing things.

Creating a dedicated backlog, we reduce the temptation to pile up hundreds of unrelated items. Then, the systematic use of Epics or Tags helps to describe smaller steps to reach the goal.

These Epics can relate to the scenarios of a user story mapping. This story map is a powerful and visual way to refine the appropriate scope to deliver business value to your users.

The backlog needs to be consistent. Whatever we're using a format or another for user stories, it should be the same everywhere.

My favorite practice for the preparation and slicing of user stories is through regular review and collaboration with the tech team. Sitting on a weekly or bi-weekly basis and refining the stories together.

There are plenty of ways to slice some value. What matters here is to do it with one (or several) tech mates who will help to slice it conveniently for the team. It also helps to avoid under or over slicing. And it reinforces a common understanding.

In my definition, a strong slicing represents a few days of work for a story for the team (at max). Healthy slicing practice supports continuous integration, making everything easier.

We usually don't need to have hundreds of detailed user stories in advance. But the next milestone scope must be clear and accurate enough. It allows the team to anticipate any potential difficulties. Or to figure out the amount of work to achieve.

Having at least the few upcoming weeks of prepared backlog content is critical for a product manager. Without this, you fall into reactive mode. It becomes challenging to have enough good time with the customers. You're not available for other teams. You have not enough time to think about the next problems to tackle.

Last but not least, the prioritization must be crystal clear; it may evolve with the learning and user feedback. But, it should draw a clear path.

A product backlog is a communication and collaboration tool. It's a living document. It requires regular grooming and cleans up, with a lot of discipline and attention.

My dear backlog gardeners, I wish you some pleasant gardening and harvesting sessions with your teams.

Why?

I was recently discussing with one of my mentors about the importance of some critical reference documentation. And also about the necessity of repetition in communication.

And an idea came while I was consolidating my meeting notes later on.

I slept on it, and it came back again, so I'm writing a short (or not) post on it.

RTFM or Read The F*cking Manual. A pretty old, and standard answer you can get when asking for a question already documented. It initially comes from a LINPACK user's manual in 1979.

Informing someone that the answer to his question exists in dedicated documentation is ok.

But the form is the worst we can find. It can make someone feeling guilty for asking something. It should never happen; any questions are right to ask; each answer brings value.

What about transforming this old RTFM thing by adding a critical missing aspect of it: be kind, be benevolent.

The Benevolent RTFM enters into the game with the following pseudo-framework.

1/ Refine the need.​

Questions about What?

• What are the recurring questions? How often are they asked?
• Who asks? Individuals, roles, teams. What are their needs?
• Where are they asked? What's the medium? Meetings, email, slack channel, calls, etc.
• When are they asked?
• Who answers, who can answer, who should answer?

Any reference document?

• Does it exist? Is it known and easy to find?
• What's it's goal or intention?
• For which public?
• Is it up to date? With an understandable format and content?
• Who maintains it? How often?

Answering these questions, we can define if there is a need to create or improve or better communicate on a piece of documentation. We specify its goal, for which public, for what expectations.

2/ Make the documentation enjoyable.​

It's now time to make sure that the ownership of the documentation is clear, that the content answers the goal, that the format is pleasant, its title is self-explicit, that the doc is up to date, and available for the given public.

3/ Make the documentation known.​

We're entering into the best part.

You can start answering questions with a kind message and a link to the specific section of the documentation.

Another critical point is to start to reference this documentation into as many other docs or decks you present and share (when it makes sense). Like if you were following a search engine optimization strategy. Make sure that this link will always be valid.

4/ Measure the progress & adapt the content.​

A lot of documentation tools include some read statistics, to know who access the doc, and when. The number of accesses of the targetted public over time is a good measure of progress. The amount of positive feedback is an even better measure.

Use the feedback to refine the needs and update the content or format accordingly.

The real magic happens when the documentation starts to be openly shared, as an organization reflex, and this, totally out of your control or actions.

You created self-service documentation.

Last words.​

While growing, as a company or as a team, we need to shift our communication from oral to written. Knowledge sharing practices have to change; small chats at the coffee machine are not good enough anymore.

Building solid documentation practices and habits become a critical asset.

This Benevolent RTFM naming made me laugh. So much contradiction into these expressions.

The main point is we should share what we know, openly, kindly, and generously. And at a particular team scale, creating a referential is the most impactful way to reach this goal.

Ludum Dare, also known as LDJam, or LD, is one of the largest worldwide game jam events.

Within a few days, thousands of developers will release thousands of games. They can join in the jam mode, working as a team, with 72h to build a game, and being able to re-use some assets. Or they can choose to participate in compo mode, aka, making everything alone from scratch in 48h.

The announcement of the theme launches the event, and the clock starts, you have to submit your game before the clock stops.

I love game jams; it's a demanding, messy, but always vibrant experience. I do prefer the jam mode. We regularly participate will a small crew, a few jam veterans, welcoming at least a new member at each session.

What can we learn from this kind of hackathon?

What can inspire us when getting back to our day to day work?

Preparation and communication​

When starting, we dedicate the first morning of the jam to brain-storm on ideas to fit the theme. We draw on a whiteboard; we don't touch a keyboard.

We're looking for an idea, a concept, a game design we're comfortable with as a team, that will keep us excited for the upcoming days.

Each teammate says what he'd like to do, game design, programming, graphics, sounds, etc. We can then pick a concept fitting what each of us we'll enjoy doing during the upcoming days. We also write down our availabilities; someone can join for half a day, one day, or three days.

Once we picked our concept, we dedicate the rest of the first day to get a working prototype, validating our idea. And during the jam days, we'll over-communicate on the progress. Doing a break together every few hours, to assess our progress, looking if someone needs help on a task.

Energy management​

The exercise is very demanding. The first-time jammer often falls into the trap of coding 24h per day.

This desperate attempt to use each available minute to deliver value quickly burns you. The first day is ok. Then you struggle with even the most simple stuff.

Balancing your energy and doing proper breaks is critical. Sleep for real, make time to eat correctly. And for our summer sessions, the game jam barbecue became a tradition for our crew.

Hard-core prioritization​

You have only a few days. Prioritization, hard-core prioritization is a must. But keep in mind that you need to deliver a great experience to your users. Storytelling. Game design. Mechanisms. Feedback.

You can quickly get trapped into something looking simple to do, but that will take far more time than expected, too much time. Not part of your core design?

Stop it, trash it. It's an excellent scoping exercise.

Be laser-focus​

Given the time frame, you'll not be excellent at each aspect that makes a great game. Our very own trick is to pick one key point, one core aspect, and be laser-focus on it. We can choose the atmosphere, the narrative, the graphics, etc.

We often pick one aspect where the first-time jammer in our crew is comfortable with or can contribute. For instance, we made a game based on the audio atmosphere when we made a jam with a sound engineer. Or a game based on the narrative with a new jammer who is an actor.

By locking this constraint, we make sure everyone in the team will push on this key differentiator. You can't be the best in all categories, but you can deliver an intense experience by picking your fights and being excellent on your differentiator.

Collaboration & team-work​

It can be very tempting to parallelize all the tasks, and for each mate to build a different piece. We noticed it's far more efficient to do some pair programming, at least, on foundations. Or to have one mate being always available to join and give a hand to any other mates. It becomes easier to parallelize the work once the foundations have been built together, with a shared understanding.

Polishing​

What makes a great experience is the level of polish. It seems counter-intuitive in a game jam, but we dedicate 30% of our time to polish the existing mechanisms and features, usually the third day of the jam.

Adding small user feedback, fine-tuning the sounds effects, the fonts, the graphics effects. Making sure the user onboarding is right, the difficulty well-balanced, that the game goals are clear.

Technical debt​

You ever heard or suffered from technical debt? A game jam is a fertile context to experiment on tech debt. Your jam team will quickly turn into an efficient tech debt factory. While rushing to add capabilities, by cutting every single possible corner, you'll soon suffer from your messy code.

And this, only after one or two days! Which is fine, you'll never touch again this codebase (hopefully). The aim is to ship a game experience, a polished prototyped, not to build a game you could sell.

Accidental successes​

Sometimes magic happens.

During a jam, we were building a platformer. Our hero wears eyeglasses, and a bug with sprites integration led to having only his glasses floating in the air. We had a lot of fun with this bug. And we discovered we could make something cool with it.

We changed our platformer to include sections in the dark where you see only the glasses of the hero. It was so good that we pivoted our concept entirely to make it the central aspect of our game, and we adapted the storytelling accordingly.

As in any project, unexpected things will happen, and a problem can become an opportunity. It could have been a boring game, and it became a unique concept, a blind platformer, on which we had great feedback. (here is the game)

Last words​

I highly encourage you to try to participate in a game jam once.

It's an exceptional experiment. It gathers all the emotions you can feel when building a product but packed within a super short time frame. The real reward is not into what you ship at the end but in the journey of trying to do it.

Cheers to my jam mates! 🎮

Here are some of our games and some others are there

In our distributed company, English is a second or third language for most of the teammates. We have a dedicated English teacher. Camille runs training and workshops to help us to improve.

Camille recently worked on our products' error messages with our product management team.

The first goal was to ensure the correctness of these messages.

She pushed the exercise at a far more advanced level.

Error messages​

When running into an error message, the experience is, most of the time, frustrating.

Something unexpected happened, and it breaks your productivity flow. You now have to understand why this piece of software does not work the way it's supposed to. You have to figure out what to do to be able to move on. And you have more interesting to do.

An error message has to be crystal clear​

Each message has to guide the user and must be self-explanatory, concise, and accurate.

When we write error messages, the temptation is high to detail as much as possible. What happened, what are the business rules. We should focus on helping the user to work around the issue and to move on.

Error messages don't have to be boring or impersonal. An error message is a way to engage with your users. It can be user friendly, using "you" and "we" pronouns creates a more human feeling.

For instance:

"Cannot remove this attribute used as a variant axis in a family variant."

"You cannot remove this attribute because it is used as a variant axis in a family variant."

Our messages have to be consistent across your whole application. We can adapt their content depending on the user persona we're talking too. But keeping a consistent tone of voice is essential.

Another good practice is to write them positively and to avoid negative sentences.

For instance:

"This value should not be blank."

"This value is required."

Conciliate these pieces of advice can be challenging, what to do when in doubt?

"The Platinium rule, if you're not sure, the rule overriding all the others, is your message has to be crystal clear." (Camille B.)

Error messages are a critical part of the UX​

Looking at most of the software I use, error messages appear to me as a second class citizen of the User eXperience.

We can fix this in our industry. We can improve. We can craft great error messages. We can make them more engaging and as enjoyable as success messages.

Last words​

Dear Camille, thank you! For pointing out this problem, for evangelizing and training our teams. Write great error messages is a step forward to deliver a more engaging experience to our users. 🦄

It has never been so easy to automate some parts of our work. Some companies made their core business of making it easier to automate all the things. Looking at you, Zapier and IFTTT!

Our time is our scarcest resource.​

Avoiding spending time on low added value tasks also means being able to dedicate more time to more important business.

Some projects that have a more significant impact on our business, on our products, on our teams.

This week, I discovered a couple of automation initiatives within our team.

Community engineering.​

We do build an open-source product. For intellectual property reasons, we need to ask each contributor to sign a Contributor Licence Agreement (CLA). And for each code contribution, coming as a GitHub pull request, we need to make sure the author has signed the CLA.

A mate built the following automation as a GitHub status check.

He also added a command to be able to check directly from our slack.

This automation creates a better experience for the contributor; he knows what he has to do. It allows the team to be more efficient, and it avoids mistakes, as it prevents any merge without a signed CLA.

Support & maintenance.​

Our support and maintenance teams observed that they spent quite some time assigning tickets to each other. Then accessing the progress, checking if they need to do something for the others.

For instance, support assigns to the maintenance once they qualified a product bug. The maintenance team re-assigns to the support team once they fixed and deployed on a test environment.

They reviewed the workflow of their respective ticket boards. And added some cross automation based on the status of these tickets.

This change comes with a re-configuration of some dashboards. It helps each mate to exactly knows what's on his plate. And ensure the info is coming to the mate, no need to run after it through various boards.

It improves collaboration between teams, making the work easier for each mate. It decreases the lead time of a support ticket by reducing the time between actions. It results in faster answers to the problems of our users.

This website.​

While writing about automation, I thought to the website you're currently browsing. I build this website with a Github repository, and I write the content using some markdown files. I have a local instance running with Docker to check the rendering. To publish the content, I write a pull request, and a CircleCI pipeline will deploy it in production once merged.

The value of this activity is in writing and sharing content, not in doing manual or tedious stuff around it.

And yes, I could use a blog engine, but it would be less fun. 🤖

Ok, let's publish now. 🚀

The first time I heard about it, I felt like I discovered a small treasure. Something that will haunt me for years, coming back again and again.

The former context was "... all models are approximations. Essentially, all models are wrong, but some are useful. However, the approximate nature of the model must always be borne in mind....". (cf source)

Yes, all we perceive, all the mental models we're building around our perception are approximations. Reality is always more complicated, fuzzy, chaotic than our representation. And it's especially true when it comes to organization and human interactions.

A wrong but useful model I like is Conway's Law, stating: "Any organization that designs a system (defined broadly) will produce a design whose structure is a copy of the organization's communication structure."

I found it often relevant. We copy the communication patterns into what we build as a team. When looking at some products or software architecture, I like to imagine the setup of the team(s) who built it.

A very strong decoupling between two features with a light integration between these in terms of UX/UI and navigation. A good chance that two different teams built these.

A very strong separation between frontend & backend code that looks like two different applications into the code base, communicating through web API. I'd bet the team is organized with the backend team on one side, and frontend team on the other.

As a team, we look for autonomy and ownership of the things we're working on. We do reproduce the communication constraints or the contracts we may have with other teams or other teammates.

When I craft a new organization or form a new team, I like to use Conway's to try to predict or to guess the outcomes. It's also known as Inverse Conway Maneuver. It's a way to promote the desired architecture or expected result by shaping the organization upfront.

Another wrong model I like is Tuckman's stages of group development.

Each time a teammate leaves a team, or each time a new member joins a team, it's not the previous team +1 or -1, it's a brand new team.

And this new team will cross different stages: Form, Storm, Norm, Perform to learn to collaborate efficiently. Each member has to find his own place within the new group. The group has to find its own way to operate.

This model can help to get prepared for the upcoming impacts when a team onboards a new teammate. It can also be used to trigger a change in the dynamic of a group. To help a team to change or re-invent their way to collaborate.

The reality is always far more complex.

These models are wrong (by definition).

But they can be useful (or not) in your context.

Stay tuned! 📻