A freelance task can touch 7 different apps before it gets done. How did we accept this as normal?

I was mapping out a pretty normal freelance project recently. Nothing particularly complex, nothing that would qualify as some huge multi-team operation. Just the kind of thing thousands of freelancers do every day: a client asks for a new landing page, a presentation, a campaign concept, a design update, a piece of copy. And when I started looking at where that one piece of work actually lives from the moment it appears to the moment it is delivered, the whole thing started to look slightly absurd.

The request arrives in email. There are a few questions, so part of the conversation moves to Slack or WhatsApp. The client sends a brief in Google Docs. You open ChatGPT to explore ideas or structure the work. The actual design happens in Figma. Assets are scattered across Google Drive. The deadline and status are tracked in Asana, ClickUp, Notion, Trello, Jira, or whatever productivity tool you are currently trying to convince yourself will finally solve the problem. Then the work is finished, and where do you go? Back to email, because that is where the client is waiting.

Seven tools. One task.

And somehow we have collectively accepted this as a normal way of working.

The weird thing is that none of these tools are actually bad

That is what makes this problem interesting. Email is good at email. Slack is good at conversations. Figma is excellent at design. Google Drive stores files. ChatGPT is increasingly useful for thinking, drafting and exploring. Task managers are good at giving you a structured view of what needs to happen. Individually, all of these products can be great. The problem does not necessarily exist inside any one of them. It appears in the gaps between them.

Because somebody still has to connect all of those places together, and that somebody is usually you. You read the email and decide that something in it is actionable. You create the task. You copy the useful part of the brief into the description. You remember which Google Drive folder contains the latest assets. You paste a client comment from Slack. You update the deadline after another email arrives. You change the priority because the client suddenly decides this is urgent. You send the finished work back through email and then, if you are particularly disciplined, return to your task manager to update the status.

At some point you have to acknowledge what role you are actually performing here.

Congratulations. You have successfully become an API.

Freelancers are doing a ridiculous amount of invisible integration work

We talk a lot about freelance administration, and usually we mean invoices, contracts, meetings, scheduling, accounting, proposals and chasing clients for feedback or payment. Those are obvious forms of admin because they are easy to see. But I think there is another category of work that we rarely name, even though many of us are doing it constantly: manually connecting information that belongs to the same piece of work but lives in completely different places.

The individual actions seem almost too small to care about. Copy the deadline. Paste the comment. Create the task. Attach the file. Move the card. Update the description. Search for the conversation. Find the right version of the PDF. Check whether the client's "yes, looks good" happened in email or Slack. None of those things feels like a serious productivity problem when you look at it in isolation. Most of them take seconds.

But they happen again and again, across every project, every client and every week. Ten seconds here, thirty seconds there, two minutes trying to remember where someone sent you something, five minutes recreating the context of a task you have not touched for four days. The bigger cost is not even the time. It is the cognitive overhead of constantly translating between systems and remembering what belongs where.

And every transition creates another opportunity for information to disappear.

Most tasks do not actually start in task managers

This is probably the strangest assumption built into modern productivity software. Open most project-management tools and they give you an empty workspace. Create a project. Create a task. Write a description. Select a priority. Add a deadline. Upload an attachment. Add a tag. Organise everything neatly.

But the work already exists.

The client has already emailed you. The brief already exists in a document. The deadline is already somewhere in the conversation. The PDF is already sitting in your inbox. Someone has already explained what they want. The meeting already happened. The useful information is there, just not in the shape that your task manager expects.

So the first thing the productivity system asks you to do is manually recreate a simplified representation of reality inside another tool.

When you think about it, that is a slightly bizarre interaction model.

The software is essentially saying: "Please explain your work to me."

And then, every time reality changes, it asks you to explain it again.

This is where I think the model might be backwards

What if the workspace did not start with a blank task?

What if it started with the things you already have?

An email from a client. A messy Slack thread. A document. A meeting note. A PDF. A random dump of information you received at 11:47 p.m. with "small changes" that are definitely not small. Instead of forcing you to translate all of that into project-management language, the workspace could understand enough of the content to help structure it.

It might notice that there are several actionable requests in an email. It might recognise a deadline. It might understand that a new message relates to an existing project. It might suggest that one of the tasks has become urgent. It might connect a file to the work it actually belongs to. It might give you a useful summary of what changed since the last time you opened the project.

Not in the "an autonomous AI agent will run your entire business while you sleep" sense. I am increasingly sceptical of products that promise that.

Something much more mundane would already be incredibly useful.

The software notices what changed, understands enough of the context to suggest what should happen next, and lets you decide.

This is one of the reasons we're building Hyzo

This problem is a big part of what we're exploring with Hyzo.

The idea is not simply to create another place where people can manually add tasks and move colourful cards between columns. There are already dozens of very good products that do that. The more interesting question for us is whether the workspace can reduce the amount of manual translation that happens before the work ever reaches the task list.

If the client sends you a long message, the useful outcome should not necessarily be that you copy pieces of that message into another system. The workspace should be able to help identify what is actionable. If a document contains several things you need to do, you should not have to manually recreate all of them. If the context of the work already exists, the system should try to use it.

We are still early, and there are a lot of questions around how much the system should infer, what it should automate and where it should simply make a suggestion. I do not think the answer is "AI should change everything automatically." For most professional work, that would probably become annoying or dangerous very quickly.

But I do think there is a huge amount of boring coordination work sitting between receiving information and actually doing something useful with it.

That is the part I want software to start handling.

If you want to see how we are approaching it, we are building [Hyzo] around exactly this idea.

Maybe we have been improving the wrong part of productivity software

For years, productivity products have become incredibly good at organising information once it is inside the system. We have better boards, better calendars, better databases, better timelines, better dashboards, better filters and increasingly sophisticated ways to organise tasks after somebody has carefully entered all the information.

But maybe the next interesting problem is not how to organise tasks better.

Maybe it is why humans are still responsible for translating so much of their working life into tasks in the first place.

Because the project does not begin when you click "Create task."

It begins when somebody asks you for something.

And between that moment and the final delivery, the work can travel through half a dozen applications while you quietly hold all of the connections together in your head.

So I am curious:

Think about the last piece of client work you completed.

How many different apps did it touch between the moment someone asked for it and the moment you delivered it?