Role Architecture & Delegation Design

1. Role architecture: designing the shape of the team

We start by mapping the real work that exists today, not job titles from a big company.

Together, we:

• List the core functions in your business – for example:
  • • Strategy and direction
  • • Service delivery and client work
  • • Sales and client acquisition
  • • Client support and communication
  • • Operations, systems and documentation
  • • Finance and admin
  • • Content, marketing or partnerships
• Map who currently does what (often: "me, me, me, me…").
• Identify clusters of tasks that naturally belong together – these become role building blocks.

From there, we design a lean role architecture appropriate for your stage. For example:

• Founder / Principal (you)
• Operations & Support (VA / ops assistant)
• Specialist Delivery Support (contractor with specific skills)
• Admin & Finance Support (bookkeeping / light admin)

We keep this architecture:

• Small – enough roles to reduce overload, not enough to create management overhead you can't sustain
• Logical – people know what they are responsible for; tasks have a clear home
• Flexible – roles can be expanded or split later as you grow

This gives you a map of who should own what, both now and in the next stage.

2. Founder role design: defining your "real job"

Right now, your "job description" is probably: "Do everything that isn't done yet."

We replace that with a deliberate founder role, by asking:

• What kind of work only you can do right now?
• Where do you create the most value – strategically, creatively, relationally?
• What work drains you but could be done by someone else with the right structure?
• What work do you want to be doing in 6–12 months?

We then define your core responsibilities, such as:

• Direction and decisions – vision, priorities, offers, positioning
• Relationship work – key clients, partners, top-level sales conversations
• High-leverage creative or strategic work
• Oversight of key systems and quality standards

And we explicitly list:

• Work to phase out of your role
• Work to hand over immediately
• Work to keep for now, but set up for future delegation

This becomes your personal operating contract: what your job is, and what it isn't. It's also a reference to check against when you're tempted to "just do everything yourself" again.

3. Delegation pathways: how work moves between people

Delegation is not just "giving someone tasks". It's designing how work flows between roles without constant friction.

We create:

Task and responsibility maps

For each priority role (often starting with an ops/VA-type role), we:

• Define clear responsibilities in plain language – not vague "support me with admin".
• Create scope boundaries – what they own fully, what they assist with, what is out-of-scope.
• Identify decision rights – what they can decide, what they propose, what they must escalate.

This prevents the two classic traps:

• You still making every decision
• Them guessing and creating new problems

Delegation frameworks

We design repeatable ways for you to hand things over, for example:

• A simple pattern for recurring tasks (e.g. weekly reports, client follow-ups, calendar management).
• A pattern for small projects (e.g. setting up a system, preparing a resource).
• A pattern for one-off requests that still need context.

Each pattern covers:

• How you brief
• What minimum information is needed
• Where the work is tracked
• How progress is communicated
• What "done" looks like

The point is to reduce the mental load of "explaining from scratch" every time.

Safety nets

Good delegation includes safety nets so you can let go without feeling reckless.

We add:

• Clear checkpoints for early review, so problems are caught early.
• Simple quality checklists for recurring work.
• Escalation rules: when and how they bring something back to you.

This lets you gradually trust the process, not just the person.

4. Onboarding & handover scaffolding

Even a well-designed role fails if onboarding is improvised.

We design lightweight scaffolding for bringing someone new into your system, including:

• A simple role overview document – purpose, responsibilities, boundaries, success markers.
• A first 2–4 weeks outline – what they should learn, do and deliver in sequence.
• A small set of "starter SOPs" and reference docs tailored to that role.
• A clear communication pattern – when you check in, through which channels, and what's expected from both sides.

We also define:

• How you'll evaluate fit in the early period
• What feedback you'll give and how
• How you'll decide whether to renew, expand or adjust the role

This turns hiring from "throw them in and hope" into a guided entry path, even if you're still a tiny company.