Will Julian-Vicary

If you're anything like me you'll receive a lot of emails on a daily basis, lots of spam, lots of actions - for me or others - and it's a means to delegate actions to others too. Managing your inbox well is, in my opinion, a core component of being a successful communicator in an office environment. Let it get out of hand and who knows what actions you've forgotten about that are lurking in the depths of your 5,000+ emails?

I've been in a position with a lot of emails for over 15 years now and this method has helped me retain my sanity when dealing with the influx of emails and demands of a busy role. I'm sharing my process in the hope that it could help others in a similar position learn from my experience and escape email hell.

This is my, *opinionated* view on how to best manage your email with Google's Gmail. My first opinion is that no one can be relied upon to not miss actions in their inbox if they have X thousand emails in there and more added daily - they're inevitably going to miss something important.

# Contents

# The TL;DR
- Inbox Zero is sanity
- Archive and use search to find emails, labels are a waste of effort
- Unsubscribe ruthlessly
- Snooze emails to get reminders on emails and get them out of your inbox
- Use threads
- Use Priority Inbox, not the Default
- Don't use a reading pane
- Use Compact or Comfortable density
- Use Conversation View
- Use keyboard shortcuts

# GTD Intro
Stepping back a little, about 5 years ago I decided to take the plunge and read Getting Things Done by David Allen (if you haven't, I strongly recommend it to anyone). And I came to the realisation that Gmail is uniquely positioned in the email market to align very nicely with GTD concepts for what is likely your busiest "inbox".

At a high level, in GTD you have a few core components:
- An inbox - Where you **capture** your actions (or with email, where actions find you!)
- Delegated Actions - Actions you've delegated to others
- A tickler file - Or a means to defer tasks so they show up at a later date
- A Next Actions list - What's up next on your plate
- A reference list - Reference material you might want to refer to at a later date
- Projects - A project is defined as something that has more than one step to it. (__Note:__ I use Omnifocus for project tasks, I don't feel these belong within email).

Simplifying things a little, within GTD you should process your "inbox" regularly, and during that processing:
- Identify if the inbox item is actionable, and if it is:
- Either: Do it immediately (<2 mins), Defer it to a future date, Calendarise it *only if it is actually a deadline*, Delegate it to someone else.
- Otherwise: File it away, trash it or add to your someday/maybe list.

# Applying this in Gmail
You probably already see some of the obvious references within email to the GTD method - most obviously, everyone has an inbox. Gmail however has some unique features that take this to the next level to really get into your GTD zen.

__This is how I handle any inbound message:__

- Will it take me <2 mins to reply? Reply immediately (shortcuts: `a` reply to all > type message > `tab` > `enter`)
- Is it spam/marketing? Archive immediately (`y` keyboard) or delete (`#`)
- Is it actionable for someone else and I want to check-in? Snooze it for a date in the future (`b`)
- Will I realistically action this soon? No? Snooze it for a date in the future (`b`)
- Is it an action for me? Add star (`s`)
- Is it an action for someone else? Forward to someone else (`f`)

__After doing this you will have:__
- Responded to quick actions, so they're out of mind.
- Starred emails in your inbox that you've committed to actioning soon. (next actions)
- Snoozed/deferred emails that you want to either action later or keep an eye on. (Deferred)
- Archived all spam/reference emails. (Filed)
- Forwarded a message to a colleague (Delegated)

__Embedded in the above are two game-changing features from Gmail:__
- Snoozed messages - will appear back at the top of your inbox with a "Snoozed from X days ago" label ⏳
- Follow-up reminders - If you delegate an email, or send an email to someone and they don't respond? Gmail will remind you to follow up 💪

__Tip:__ If a task belongs to a project and/or it's a larger request from a colleague, I'll move the action to my Omnifocus inbox and process it there later as a project. The email remains as a communications means only, I'll defer that email as a self-reminder to follow-up and give updates to my colleague.

# Configuring Gmail for GTD
While out of the box Gmail is good, there are a few things I will always change to make it work for me and within the GTD workflow.

## Switch to "Priority Inbox"
The default view is to show 5 different tabs which auto-file emails into different tabs. This might be suitable if you're not on top of your inbox, but personally having 4 additional inboxes is not progress and the auto-filing is often incorrect.
![gmail-default-inbox](//images.ctfassets.net/6isqj05m1pz3/4rUGFF6cKwb5opECr24nEB/39d237630cd9032052c0688ffa5a058a/gmail-default-inbox.png)

Switching to Priority inbox gives you a single inbox with 3 different splits, but all visible at all times:
![gmail-priority-inbox](//images.ctfassets.net/6isqj05m1pz3/1OloaMuIStFoElmsrxDyYt/0db55616fb794968310b1c20b3a4d3d9/gmail-priority-inbox.png)

This allows me to see:
- New emails, and those that Gmail has decided are priority (which it is generally pretty good at)
- Emails I have starred (next actions)
- Everything else in my inbox (needs review)

## Switch on "Reply to all" as the default
There is little more annoying than being looped out of a conversation by someone that is incapable of replying to all - don't be that person, apply that as your default.
> Settings > General > Default Reply Behaviour > Reply all > Save

## Enable "Auto Advance" so you can tackle your inbox quickly
Auto-advance is an advanced setting that, once you've finished with an email and archive it, it'll show you the next email - if you want to master your inbox this is a must have toggle.
> Settings > Advanced > Auto-Advance > Save

## Make sure nudges are switched on
Nudges is Gmail reminding you to either reply to a message (if this happens, you're probably losing control of your inbox) or to follow-up (if someone else has lost control of their inbox - this one is more likely!).
> Settings > General > Nudges > Check box on > Save

## Conversation view
I know conversation/threaded view isn't for some people, but personally I don't want 5 separate emails in my inbox if it's all part of the same chain - bring on the threading I say.
> Settings > General > Conversation View > Conversation View __On__ > Save

## Change density
I prefer a "Comfortable" density, it strikes a nice balance between Compact and the Default View (which is suddenly quite busy).
> Quick Settings > Density > Comfortable

## Enable Keyboard Shortcuts
If you want to tackle your inbox quickly, keyboard shortcuts are a great tool to support that.

To enable them:
> Settings > General > Keyboard Shortcuts > Keyboard Shortcuts On > Save

I use these hundreds of times a week:
- `y` archive email
- `a` reply to all
- `f` forward
- `s` star
- `tab+enter` sends current email (when writing email)
- `b` snooze
- `cmd+shift+c` Add someone to CC
- `cmd+shift+b` Add someone to BCC

# General tips
- Don't use labels, I get the appeal and used to aggressively label things myself, Gmail's search is so good I find labelling simply a waste of time. If I need something I can generally find it very quickly with the search. The exception is [automated filtering rules](https://support.google.com/mail/answer/6579?hl=en-GB) where I will use labels to *label + skip the inbox*
- Get used to the keyboard shortcuts, they'll dramatically speed up your processing time (hit `?` anywhere in Gmail once they're enabled for a refresher on the shortcuts).
- Have your calendar open in the Side Panel to quickly add email recipients to meetings as needed.
- Switch notifications off, you don't need the constant reminders your inbox is busy. Open it at times of the day to review, otherwise you will get lost in your email.
- Have a million emails in your inbox? Archive *everything* now and start afresh.
- Unsubscribe from newsletters your don't care about promptly, they'll add up fast and create noise.
- Get familiar with the search syntax in Gmail, it's incredibly powerful as one example `to:groupmailbox@domain.com -to:myemail@domain.com` will allow you to filter all emails to a group emailbox, EXCEPT those that call your email address out directly - super handy if you're in a noisy mailing list.
- This is my personal opinion but I __don't__ have "Send + Archive" enabled, I often send an email and then snooze the thread for later to remind me to provide an update so prefer to manually hit `y` to archive the email after sending an email if I'm done with it.

# How about you?
What's your process look like? Are you in a good place with your inbox or drowning in email hell? I hope this helps at least provide some food for thought when dealing with your email, I know it's helped me keep my sanity!

Looking to up your email game? GTD paired with Gmail is a great way to achieve email zen. I share the exact method I use to manage my day-to-day inbox in this article.

Implementing GTD in Gmail, A Guide

*This post was originally shared on Medium.com*

I was looking for a simple method of exporting a Laravel Resource to a CSV file, there is no native method of doing
this however as you’ve already modelled how your data should look in an API it seems a little backward to re-model
your data for exporting, it’s much nicer to re-use the Resource that you’ve already pre-defined.

I found the below to be reasonably elegant way of exporting a Laravel resource to CSV file as a trait on the Resource.
This handles nested data by appending the parent key with an underscore affix and iterates hierarchically where needed.
This solution makes use of an `AnonymousResourceCollection` (the same approach laravel takes when you run
`Resource::collection($data);` ).

**Note:** This relies on [League\CSV](https://csv.thephpleague.com/) to generate the CSV file.

**ExportTrait.php:**
```php
<?php

use Illuminate\Http\Resources\Json\AnonymousResourceCollection;
use League\Csv\Writer;

trait ExportTrait
{
    /**
     * Exports a CSV from a provided resource collection
     * @param mixed $resource
     * @param string $filename
     * @return int
     * @throws \League\Csv\CannotInsertRecord
     */
    public static function exportCSV($resource, $filename = 'export.csv'): int
    {
        $resourceCollection = new AnonymousResourceCollection($resource, static::class);
        $data = $resourceCollection->toArray(request());
        $csv = Writer::createFromFileObject(new \SplTempFileObject());

        $i = 0;
        // Build the CSV
        foreach ($data as $key => $datum) {
            // Add the headers into the document
            $row = self::assocToFlat($datum);
            if ($i === 0) {
                $csv->insertOne(array_keys($row));
            }

            $csv->insertOne($row);
            $i++;
        }

        return $csv->output($filename);
    }

    /**
     * Turns an associative array into a flat array, with hierarchical key names joined by underscore
     * @param $dataRow
     * @param string $prefixKey
     * @return array
     */
    private static function assocToFlat($dataRow, $prefixKey = ''): array
    {
        $return = [];
        foreach ($dataRow as $key => $item) {
            if (!is_array($item)) {
                $return[$prefixKey . $key] = $item;
                continue;
            }

            $return = array_merge($return, self::assocToFlat($item, $prefixKey . $key . '_'));
        }

        return $return;
    }
}
```

Add the trait to a resource you want to export:

```php
<?php

namespace App\Http\Resources;

use Illuminate\Http\Resources\Json\JsonResource;
use Support\Resource\ExportTrait;

class MyResource extends JsonResource
{
    use ExportTrait;

    /**
     * Transform the resource into an array.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return array
     */
    public function toArray($request)
    {
        parent::toArray($request);
    }
}
```

Then, when you have your data available, the following command will set the necessary download headers and export a CSV file based on your resource specification.

`MyResource::export($data);`

A simple trait that exports a Laravel Resource to CSV, supporting consistently nested arrays of data.

Export Laravel Resource to CSV trait

This is my first* post of, hopefully, many on my new website. I had an impulse to share and the planets aligned with Tailwind UI releasing a [new template](https://tailwindui.com/templates/spotlight) - that, coupled with a long time appetite to trial NextJS and well, here we are!

This website is built with NextJS, Tailwind and Contentful as my headless CMS. My next post will go into a little more detail on how that looks technically behind the scenes.

\* I imported a few posts from Medium, so... technically this isn't the first post 🤷‍♂️

My posts here will cover:

* Programming tips and tricks, most probably with Laravel and/or PHP (as my backend of choice)
* Reminders to my future self about useful techniques, sharing for my own benefit and that of others.
* Technical marketing deep dives and opinions.
* Productivity tips and hacks - sharing how I stay productive as a IC and manager.

You have to start somewhere right - Hello World feels like a pretty good place to start!