When I wrote about professional resilience as owning a structure for your thinking, I was mostly looking at long term continuity – how to carry your ideas and mental scaffolding with you when jobs end and systems disappear.

A modern job search is where that idea gets stress-tested.

There are job boards, email threads, LinkedIn messages, CV versions, interview notes and rejection letters. Everything is urgent, emotional and time-sensitive. It is very easy to end up with a browser full of tabs, half-remembered opportunities and a nagging sense that something has slipped through the cracks. At one point I had three versions of the same role open in different tabs and still couldn't remember whether I'd actually applied.

I realised that if I was serious about treating my own career as something I am responsible for, I needed to run my job search the way I would run a product system: with a single place that holds the work, a clear flow from "seen" to "decided", and enough structure that I could trust it when my head was full.

For me, that place is DEVONthink.

This isn't a tutorial on DEVONthink, and it's not an argument that everyone should use it. What follows is simply how I've set things up so that my job search feels less like firefighting and more like working a plan.

One database, one backbone

I keep all job-related material in a dedicated DEVONthink database. It holds:

The rule is simple. If it relates to the search, it lives there. Not in my inbox, not in a downloads folder, not as a stray note in another app. That alone makes a difference, because it means there is one place to open when I "go to work" on the search.

Within that database, the structure is deliberately boring:

Each role group holds everything for that opportunity: the original job description, the application text, tailored CV, notes, and any follow-up. It is the chunk of work. When I click into it, I see the whole story of that role.

Metadata instead of memory

The thing that actually makes this useful is not the folders, it is the metadata.

Each role record – the top-level document that represents the opportunity – has a set of custom metadata fields. The labels are tuned to how I think about the search:

Over time I have added small, practical fields. For example, a boolean "Expression of Interest" flag for speculative approaches, and a "Stale" flag driven by a smart rule that looks at last modified date.

The point of this is not to collect data for its own sake. It is to stop my brain having to remember everything. When I look at a list of roles, I can see in one glance which are active, which are waiting, which are effectively dead, and why I decided to pass on others.

The "No-Go reason" field is especially helpful. Instead of leaving roles in a vague "maybe later" pile, I make myself choose a short reason: specialism not aligned, seniority mismatch, location, compensation, or simply "does not excite me". That sounds trivial, but it keeps the list honest and it stops zombie roles from clogging up my attention.

Treating roles as items in a flow

Because each role has a status and structured metadata, I can treat the list like a product board.

New roles arrive in "Seen" or "Considering". Once I decide to move on one, I set it to "Applying" and run a script that builds out the job folder: it creates the group, stubs for application text, a copy of the relevant CV, and any standard notes I want to capture.

When an application is actually sent, I move the status to "Applied", add the date, and link or import the confirmation email. If the process advances, "Interviewing" gets dates and people. If it dies, "Closed" with the reason.

The benefit of this is not that it looks neat. It is that I always know what today's work is. On any given morning I can:

It is a small version of how I have run shared technology and production backlogs in teams, but pointed at my own life.

Automation as glue, not magic

DEVONthink is flexible, but it can also be fiddly if you have to do the same steps by hand all the time. That is where a little automation helps.

I have a handful of AppleScripts that handle the repetitive parts:

Individually these are small wins, shaving off seconds rather than hours. Together they change the feel of the work. Instead of clicking around, renaming files and dragging things into place, I can stay in the mindset of evaluating roles and writing applications.

To me, that is the real point of automation here: not to impress anyone with clever scripts, but to protect my attention for the decisions only I can make.

An audit trail for my own sanity

One of the quieter benefits of this setup is that it gives me an audit trail I can read.

For any role I can see:

That matters more than I expected. Job searching can be demoralising. It is easy to feel as if nothing is happening, or that you are somehow not doing "enough". Being able to scan the history of a few weeks of applications and conversations is a good antidote to that story.

It also feeds back into my judgement. If I see a pattern of "Closed – specialism not aligned", that is a useful signal about where I am aiming. If a certain source or type of role consistently stalls, I can choose to spend less time there.

In other words, the system gives me a memory of the search that is more accurate than whatever my mood might be telling me on a given day.

Why bother?

None of this guarantees a job. The market is still the market. What this structure does give me is:

More importantly, it keeps a sense of control during a period that can feel anything but controlled. I am not just reacting to whatever lands in my inbox. I am running a process that I understand and can improve.

In the next piece I will dig into how I plug AI into this setup – using it to analyse job descriptions, compare them with my CV, and draft tailored applications – and why it only works because the underlying structure is already there.