FreshBooks and CodeWords: getting time onto invoices

FreshBooks is built for businesses that sell time. That shapes where the money actually leaks, and it is not where most accounting automation looks.

The leak is between work happening and time being recorded. Hours logged three days late are logged from memory, and memory rounds down. Work that took forty minutes becomes half an hour, and the fifteen-minute call nobody logged at all becomes nothing. For a service business, that gap is revenue, and no amount of invoicing automation recovers time that was never captured.

What we'll cover

• Where service businesses actually lose money
• What the FreshBooks API reaches
• Connecting it to CodeWords
• Eight automations worth building
• Capturing time closer to the work
• Chasing payment without damage
• Building it so it survives
• Limits worth knowing about
• What to build first
• Frequently asked questions

Where service businesses actually lose money

Unlogged time. The call, the email that took twenty minutes to write, the review somebody did on the train. Individually trivial, collectively a meaningful share of a week.

Time logged late. Reconstructed on Friday from a calendar and a vague memory, which systematically under-counts.

Unbilled time that was logged. Hours sitting against a project that never made it onto an invoice because whoever assembled the invoice worked from a different list.

Scope creep nobody priced. A project quoted at twenty hours that has absorbed thirty-five, visible only when somebody totals it, usually after delivery.

Slow invoicing. An invoice sent three weeks after the work is an invoice paid five weeks later, and a client who has moved on and forgotten the detail.

Notice that four of the five happen before anything reaches an invoice. That is where the automation should aim.

What the FreshBooks API reaches

Time entries can be created, read, and updated against clients, projects, and services, which is the foundation here.

Projects can be read and written with their budgets and rates, including whether they are fixed-price or hourly.

Invoices can be created, read, updated, and sent, with line items that can be built from time entries.

Clients can be read and written, with their rates and terms.

Expenses can be created and marked billable, so pass-through costs reach the invoice.

Payments can be recorded and read, which is how chasing knows what is outstanding.

Estimates and proposals can be created, which matters for anything comparing quoted against actual.

Webhooks notify on invoice, payment, and project events.

Connecting it to CodeWords

CodeWords connects to more than 3,000 integrations, and the connection is made once and reused.

1. Open CodeWords and start a new automation.
2. Describe what should happen in plain language to Cody, the automation builder: where the record of work lives, and how it should become time or an invoice.
3. Authorize the connection through FreshBooks OAuth, scoped to the business involved.
4. Describe the exceptions: work that cannot be matched to a project, time that looks implausible, an invoice with nothing to bill.
5. Run it as suggestions for a fortnight before anything creates entries directly.

You describe the outcome; Cody builds it, connects it, and deploys it. The free plan covers light use, with Pro at $39 per month and Business at $100 per month as usage grows; details are on the pricing page.

Eight automations worth building

Time suggestions from the calendar. Read yesterday's meetings, match them to clients and projects, and present suggested entries for confirmation. Confirming a prepared list takes a minute; reconstructing the day takes twenty and misses things.

Unlogged gap detection. Compare hours logged against working hours for each person and flag the days with large unexplained gaps. Not to police anyone — to prompt the memory while it still works.

Unbilled time reporting. Time logged against projects that has not reached an invoice, by client and by age. This is the most directly monetary report on this page and most service businesses have never run it.

Draft invoices from time. At the billing date, assemble a draft invoice per client from unbilled time and billable expenses, grouped the way that client likes to see it, ready for review.

Budget burn alerts. When a project passes a proportion of its estimated hours, tell whoever owns the client relationship, while there is still time to have a conversation rather than after delivery.

Quoted against actual. Compare estimates to what projects actually consumed, by type of work. This is what turns bad quoting into better quoting, and almost nobody tracks it.

Payment chasing with judgement. Overdue invoices, checked against payments received, chased on an escalating schedule with a cap.

Client profitability reporting. Revenue against hours by client, including the unbilled hours, so you can see which clients are genuinely worth having.

Capturing time closer to the work

The highest-value thing here and the least automated in most firms.

Prompt, do not police. An automation that says "you logged two hours on Tuesday and had six hours of meetings, does something need adding?" is helpful. One that reports the same fact to a manager is surveillance, and it changes what people log rather than what they do.

Suggest from what already exists. Calendar entries, sent email, commits, tickets touched, documents edited. Most work leaves a trace somewhere, and a suggested entry derived from one is far easier to confirm than a blank form.

Make confirming trivial. A daily message listing suggested entries with a way to accept or adjust them is the difference between time being logged daily and time being reconstructed weekly.

Never create billable entries without confirmation. Time that goes on a client invoice must have been confirmed by the person who did the work. Automatically billing inferred hours is a fast route to a difficult conversation.

Round the way you actually bill. If you bill in six-minute units, suggest in six-minute units. Suggestions in a different granularity get edited every time, which removes the saving.

Chasing payment without damage

For a service business the client relationship is the asset, and an automated chase is a relationship touchpoint whether you intended it as one or not.

Verify it is actually unpaid. A payment received and not yet recorded produces a chase for money already sent, which is the worst version of this.

Exclude anything in conversation. A client disputing an invoice, or mid-discussion with somebody on your team, should not receive an automated reminder. This requires checking somewhere other than FreshBooks, which is exactly why the automation lives outside it.

Escalate slowly and stop. A reminder a few days after due, a firmer one after a fortnight, then a person. Automating past that point is where recoverable situations become written-off ones.

Reply to a human. A chase from a no-reply address tells a client you do not want the conversation that usually gets it paid.

Never automate anything with a legal character. Final demands are written and sent by a person who has decided to send them.

Building it so it survives

Make it safe to run twice. Creating duplicate time entries or invoices is worse than inconvenient, since both reach a client. Check for existing records with the same reference before writing.

Treat unmatched work as an exception, not a guess. A calendar entry that could belong to two clients should be presented for a decision rather than assigned to the likelier one.

Log what was suggested and what was accepted. The acceptance rate tells you whether your matching is any good, and it is the number to watch as you tune it.

Keep billable and internal clearly separate. An automation that accidentally marks internal time billable produces an invoice a client will query, which costs more than the time was worth.

Send a daily summary. What was suggested, what was created, what needs attention.

Limits worth knowing about

Rate limits apply, so bulk historical analysis needs pacing.

The account and business structure matters. FreshBooks scopes data per business, and a multi-entity setup needs that handled explicitly rather than assumed.

Time entries belong to a person, so an automation creating them on somebody's behalf is asserting something about their day, which is a reason to prefer suggestion over creation.

Fixed-price projects still benefit from time tracking even though the hours do not drive the invoice, and an automation that only handles hourly projects misses the profitability question entirely.

Sent invoices should not be silently edited. Once a client has it, a correction is a credit note and a conversation rather than an update.

What to build first

Unbilled time reporting, read-only: hours logged against projects that have never reached an invoice, by client and by age. It needs no write access, it takes minutes, and in most service businesses the first run finds real money.

Two habits make the difference. Run it alongside your normal billing cycle and compare what it found against what got invoiced. And have it report even when the list is empty, because a silent check cannot be distinguished from a broken one.

Frequently asked questions

Can an automation log time for me?

It can suggest entries from your calendar, your commits, or your sent mail, and a person should confirm before anything becomes billable. Confirming a prepared list takes a minute and captures far more than reconstructing a week does, which is where the actual gain is.

Will time suggestions feel like monitoring?

Only if you send them to a manager. Sent to the person who did the work, as a prompt while they still remember, they read as helpful. The distinction is entirely about who receives it, and getting that wrong changes what people log rather than what they do.

Should invoices send automatically?

Drafts for review, in nearly all cases. An invoice is a client communication and the review catches the line that reads wrong, the work that was written off, and the item that should have been split. Recurring retainers with fixed amounts are the reasonable exception.

How do I find work that never got billed?

Report time logged against projects with no corresponding invoice line, aged by how long ago the work happened. This is the single most valuable report here and most firms have never produced it, which is why the first run is usually uncomfortable.

Can it tell me whether a client is profitable?

Yes, if you track time on fixed-price work as well as hourly. Revenue against total hours including unbilled and written-off time is the honest figure, and it is frequently different enough from the assumed figure to change who you take on.

How do I stop chasing a client who has already paid?

Check payments before sending, every time. A payment received and not yet reconciled is common, and a chase for money already sent damages the relationship more than the reminder was ever worth.

What about expenses I need to pass through?

Mark them billable when created and have the invoice automation include them alongside time. Pass-through costs missed at invoicing are a quieter version of the unbilled time problem and they are just as recoverable.

How do I handle work that spans several projects?

Split it at logging rather than at invoicing, because reconstructing which client an hour belonged to is guesswork by the end of the week. Where the split is genuinely ambiguous, suggest a division and let the person adjust, which is faster than asking them to start from nothing.

Should retainer clients be handled differently?

Yes. For a retainer the useful automation reports consumption against the retained amount rather than assembling an invoice, so the conversation about overage happens before the month ends rather than after.

What is a realistic recovery from better time capture?

Enough to notice, and the honest answer is that it varies with how bad your current capture is. The measurable version is to compare hours logged per person per week before and after suggestions start arriving; teams who were reconstructing on Fridays usually see the difference within a fortnight.

Related reading

• Xero and CodeWords
• QuickBooks and CodeWords
• CodeWords integrations and templates