The Google Sheets Payroll Pipeline:
Timesheet Photos to Calculated Wages

The Six Handoffs Between Receiving a Timesheet and Paying an Employee

Deloitte's 2024 Global Payroll Benchmarking Survey, presented at the annual PayrollOrg (formerly American Payroll Association) Congress, found that more than 30% of payroll processing time is spent manually entering and loading payroll inputs — the step where raw data from time records, adjustments, and corrections gets into the system before any calculation even begins (Bloomberg Tax, June 2025). For large employers, that 30% represents paid staff hours. For a small business using Google Sheets as its payroll register, it represents the owner or office manager working late the night before payday.

Trace the journey of one timesheet from receipt to row, and the handoff problem is structural, not accidental:

1. Receive — timesheet arrives as paper, photo via text, or email attachment
2. Open — switch from your spreadsheet to whatever viewer displays the timesheet image
3. Read — locate each field across a document with no standardized layout: employee name here, date there, hours written at the bottom in a different handwriting every week
4. Type — transcribe each value into the correct cell in Google Sheets
5. Verify — cross-check the cell against the image, because mistyped hours means mispaid employees
6. Calculate — now apply formulas: =Hours*HourlyRate, =OT_Hours*HourlyRate*1.5, =Gross+OT_Pay

Steps 1 through 5 are pure transcription — moving information that already exists from one medium to another. Step 6 is the only step that adds value. Yet steps 1-5 consume roughly 80% of the time budget for any payroll cycle that starts with paper or photo timesheets.

An Intuit QuickBooks survey of 1,006 U.S. employers found that 82% of small business owners manually review every payroll calculation to ensure accuracy, and 63% never realized how much time they were spending on payroll-related tasks until they sat down and measured it. The verification step isn't paranoia — it's rational. When a transcription error changes an employee's take-home pay, the cost isn't just the correction. It's the trust repair with someone who depends on that paycheck being right.

Why Payroll Software Doesn't Solve the Timesheet Input Problem

There is no shortage of payroll software for small businesses. Gusto starts at $49/month plus $6 per employee for full-service payroll with tax filing. QuickBooks Payroll Core costs $50/month plus $6.50 per employee and integrates natively with QuickBooks Online. ADP RUN starts around $79/month plus $4 per employee. Patriot runs $17/month plus $4 per employee for basic payroll. OnPay at $49/month plus $6 per employee handles multi-state filing. These are mature, capable products. They calculate wages, withhold taxes, file 941s, and process direct deposits.

None of them extract handwritten hours from a photo of a paper timesheet.

The payroll software market has invested heavily in automating the back end — tax calculation, deposit scheduling, year-end W-2 generation. The front end — the moment data enters the system — is still a keyboard problem. If your workers clock in on an app (Clockify, Toggl, Harvest, or the built-in time clocks in Gusto and QuickBooks Time), the data flows digitally. If they sign a paper sheet and someone photographs it with a phone, the data stops being digital at the moment of capture and has to be digitized again by a human.

This is precisely the scenario that keeps small businesses using Google Sheets for payroll despite the existence of dedicated software. The business owner who built a payroll register in Sheets three years ago — with conditional formatting that highlights overtime rows, a pivot table that feeds quarterly 941 preparation, and columns ordered exactly the way their accountant expects — has no incentive to migrate to a platform that still can't read a photo of a timecard. The sheet works. What doesn't work is the loop that feeds it.

The Three-Layer Pipeline: Capture, Extract, Calculate

A pipeline is different from a tool. A tool does one job — extract data from a timesheet. A pipeline moves data through three connected stages, each feeding the next without a keyboard in between. For a business whose payroll lives in Google Sheets, the pipeline has three layers that all operate inside the spreadsheet environment:

The three layers all operate inside Google Sheets. No uploading to an external web dashboard. No downloading CSVs and reformatting column headers. No switching between a photo viewer, a spreadsheet, and a calculator. The sidebar is the only interface, and the active sheet is the only destination.

The add-on's output can be exported as Excel (XLSX) or CSV, and it supports batch processing — upload multiple timesheet photos at once and extract all of them into consecutive rows in a single pass. For a pay period with 20 employees, that's one batch upload instead of 20 individual typing sessions.

Computed Columns: Where Extraction and Payroll Calculation Merge

The traditional extraction-to-payroll workflow separates two steps that should be one. You extract hours into columns A through E. Then in column F you write =D2*HourlyRate, in column G you write =E2*HourlyRate*1.5, in column H you write =F2+G2. You drag the formulas down. If your sheet has 200 rows of historical payroll data, you're managing formula ranges every pay period — ensuring the formulas extend to the new rows but not beyond, watching for broken references when someone sorts or inserts a row above.

Computed columns collapse the extraction step and the calculation step into a single moment. Instead of extracting "Regular Hours: 40" and "Hourly Rate: $22" into separate cells and then building a formula to multiply them, you define a column that returns the product directly. The extraction engine reads 40 hours from the timesheet, reads $22 from your column specification, and outputs $880.00 in the cell.

Here are the computed column definitions that turn raw timesheet extraction into a payroll-ready row:

For more complex calculations — such as referencing multiple rates from a lookup table or applying conditional overtime rules — the Rule Format (available to logged-in users) lets you define multi-step computation logic in JSON while keeping column names clean. This is where a pipeline diverges from a simple extraction tool: the calculation is embedded in the extraction pass, not layered on top of it afterward.

Compare the two approaches across a 20-employee pay period:

The difference isn't theoretical. In the traditional workflow, every new pay period brings a new opportunity for a formula range to get misaligned — especially if employees are added or removed between periods. In the pipeline workflow, the output of every row is self-contained. Row 47 doesn't depend on a formula in column H that references columns F and G. The value in H was calculated during extraction, stored as a plain number, and won't break if someone inserts a row above it.

The extraction engine handles printed text and handwriting — including cursive and mixed formats — with up to 99% accuracy for printed table data, processing each page in 5-10 seconds. A single timesheet photo typically processes in under 10 seconds through the sidebar.

Overtime Compliance: When State Rules Require More Than 1.5× After 40

Federal FLSA overtime is straightforward: 1.5 times the regular rate for hours beyond 40 in a workweek. Most states follow this standard. California, Colorado, Nevada, and Alaska add daily overtime triggers that complicate the calculation considerably — and the businesses most likely to use a Google Sheets payroll pipeline are the ones least likely to have a compliance department checking their formulas.

California's overtime structure is the most aggressive and the best illustration of why the calculation layer matters:

If your employee worked 50 hours in a week, 10 of which were beyond 8 in a day and 2 of which were beyond 12, your payroll row needs to split total hours into three buckets (regular, 1.5× OT, 2× OT) and apply different multipliers to each. In a traditional spreadsheet, that's three separate IF formulas — each one a potential failure point when it's 11 PM the night before payday.

For employees who work at multiple rates — a restaurant server who also bartends, earning $12/hour for serving shifts and $16/hour for bar shifts — the FLSA requires a weighted average regular rate for overtime calculation (DOL Fact Sheet #23). Total earnings from all rates are added together and divided by total hours worked. This computation is notoriously error-prone in spreadsheets, and it's the kind of calculation that payroll software like Gusto and ADP handle automatically — but only when hours are entered directly or clocked through their app.

For a Google Sheets pipeline, these complex overtime rules are addressable through inferred columns and computed column logic. An inferred column classifies each shift into a pay category based on hours-worked thresholds. A computed column then applies the correct multiplier per category. For weighted-average scenarios, the Rule Format (JSON-based computation rules for logged-in users) can reference multiple extracted fields and perform the division in a single pass. The result is a payroll row that has already segmented and calculated pay at the correct rates before it hits the sheet — no IF formulas required.

Recordkeeping: What the FLSA Says Your Spreadsheet Needs to Prove

Under 29 CFR Part 516, every employer covered by the Fair Labor Standards Act must maintain specific records for each non-exempt employee. The regulation doesn't require a particular form or format — a Google Sheet is legally sufficient as long as the required data points are recorded and preserved (29 CFR § 516.2). But the list of required fields is longer than most small business owners realize:

The two-year/three-year distinction is important and commonly misunderstood. Payroll records — the final dollar amounts, dates, and employee identifiers — must be preserved for at least three years from the last date of entry. The source documents on which those wage computations are based — the actual timesheets, time cards, and rate tables — must be preserved for at least two years (DOL Fact Sheet #21). A pipeline that stores extracted data in Sheets (for the 3-year record) and original timesheet photos in Google Drive (for the 2-year record) satisfies both requirements simultaneously — without a filing cabinet.

For payroll tax purposes, IRS Publication 15 (Circular E, 2026) adds its own timeline. Employers must determine their deposit schedule — monthly or semiweekly — based on a lookback period (the 12 months ending June 30 of the prior year). Employers with $50,000 or less in reported employment taxes during the lookback period follow the monthly schedule (deposit by the 15th of the following month). Those above $50,000 follow the semiweekly schedule — deposits by Wednesday for paydays falling Saturday through Tuesday, or by Friday for paydays falling Wednesday through Friday. Either way, the actual dollar amounts driving those deposits start with the extracted and computed data in the pipeline's output rows (IRS Pub 15).

Pipeline Under Pressure: Month-End Payroll Close

Most month-end payroll close articles focus on the reconciliation checklist: verify hours against timesheets, confirm overtime classifications, check for missing employees, calculate gross-to-net, reconcile tax deposits. The checklist is well-documented. What those articles don't capture is the time compression — all of those verification steps happen in the 24-48 hours before the direct deposit deadline, because the transcription step consumed the earlier part of the processing window.

The pipeline model shifts the time allocation. When extraction and wage calculation happen in a batch pass from the sidebar — 20 timesheet photos processed in minutes instead of 40 minutes of typing — the verification window expands. The office manager who used to spend Wednesday night transcribing and Thursday morning calculating now spends Wednesday morning reviewing and Thursday morning filing. The same checklist gets executed with a clearer head and more time to catch anomalies — like an employee whose hours jumped 60% from the prior pay period or a missing timesheet that would have been discovered at 4:45 PM on deposit day.

The cost of manual timesheet entry includes not just the wages of the person doing the typing, but the downstream cost of compressed review windows — the payroll errors that happen when verification gets squeezed into the hour before the EFTPS cutoff.

What the Pipeline Does — and What It Doesn't Do

Honesty about scope is essential. The Google Sheets payroll pipeline described here handles extraction, wage calculation, and data structuring. It does not:

• File payroll taxes. The pipeline calculates the gross wages that drive your tax liability, but you still need to deposit FICA and income tax withholding through EFTPS or a payroll provider — your pipeline output feeds the deposit calculation; it doesn't initiate the deposit.
• Process direct deposit or print checks. The output is a calculated dollar amount in a spreadsheet cell. How you get that dollar amount to your employee — direct deposit through your bank, a paper check, a payment app — is a separate step.
• Calculate net pay with federal/state withholding. The pipeline can compute gross pay (the extraction-to-wages path). Net pay — after federal income tax, Social Security (6.2%), Medicare (1.45%), state tax, and any voluntary deductions — requires additional computation that you can layer into your sheet with formulas or reference tables after the pipeline delivers gross amounts. The computed columns can handle a flat withholding percentage (e.g., Net Pay (Gross × 0.78)), but accurate tax withholding should reference IRS Pub 15-T tables, which vary by filing status, W-4 elections, and pay frequency.
• Generate W-2s or file Form 941. The pipeline delivers structured payroll data — the input to those forms — but does not produce the forms themselves.

Think of the pipeline as the layer that closes the gap between "the timesheets are here" and "the payroll data is ready to be deposited." Everything upstream from deposit — tax calculation, form filing, payment distribution — still belongs to the tools and services you already use for those functions.

The Same Pipeline Pattern, Different Document

If this three-layer pipeline structure — capture, extract, calculate — sounds familiar, it should. The same architecture powers the Google Sheets invoice pipeline for supplier-to-AP workflows. In that pipeline, supplier invoices arrive as email attachments, get extracted through the same sidebar add-on, and populate an AP tracking sheet with computed columns for line-item totals and tax verification. The document type changes, but the pipeline logic is identical: remove the handoffs between document arrival and structured data, and let the spreadsheet be the system it already is.

For businesses that handle both timesheets and supplier invoices — construction firms, restaurants, field service companies — the two pipelines run in parallel, sharing the same add-on, the same extraction engine, and the same Google Sheets environment. The learning curve for the second pipeline is zero, because the first one already established the pattern.

FAQ

Can the add-on handle handwritten timesheets?

Yes. The extraction engine uses vision-model-based recognition that handles printed text, handwriting, cursive, and mixed formats on the same page. Accuracy varies with handwriting legibility — the same as a human reader. Printed table data achieves up to 99% accuracy; handwriting accuracy depends on clarity. The engine identifies and extracts data from tables, checkboxes (ticked/circled), and mixed text-image layouts. For more detail, see the handwritten timesheet accuracy guide.

How many timesheets can I process at once?

The add-on supports batch processing — upload multiple timesheet photos simultaneously and extract them into consecutive rows of your sheet in a single pass. Usage is governed by your plan's credit quota, with credits consumed per page. A 20-employee pay period with one-page timesheets each is 20 pages — processable in one batch from the sidebar.

Can the pipeline handle employees with different hourly rates?

Yes, through two approaches. For simple cases where each employee has a fixed rate, reference the rate directly in the computed column definition — e.g., Regular Pay (Hours × 25) for a $25/hour employee. For employees with varying rates across roles, use a reference table in your sheet (with VLOOKUP or INDEX-MATCH) and a flat percentage-based computed column, or use Rule Format to embed multi-step logic. The weighted-average overtime calculation required by the FLSA for employees with multiple rates can be handled through inferred columns + Rule Format for logged-in users.

How is this different from using a time tracking app like Clockify or Toggl?

Time tracking apps capture hours as employees work them — they require every worker to have the app, to remember to start and stop the timer, and to have a phone or computer at hand. They're excellent for knowledge workers and desk-based teams. The pipeline model described here is for the opposite scenario: workers who fill out a paper timesheet at the end of a shift (construction crews, kitchen staff, field technicians) and whose hours arrive as a photo. The two approaches serve different workforces. They're complementary, not competitive — a pipeline can process paper-based timesheets alongside app-tracked hours in the same spreadsheet.

What happens if an employee's hours were extracted incorrectly?

The add-on is not a black box. You see the extracted values in the sidebar before they're committed to the sheet. If a field looks wrong — a misread "8" that should be "3," a date parsed incorrectly — you can edit it in the sidebar preview before appending to the sheet. This verification step is built into the pipeline workflow. Once data is in the sheet, it's standard spreadsheet data — editable, sortable, auditable, like any other cell value. There's no locked data format or proprietary output file.

Does the add-on file payroll taxes or generate paychecks?

No. The add-on extracts timesheet data and computes wages. It does not file Form 941, make EFTPS deposits, generate W-2s, or process direct deposits. Those functions remain with your existing payroll provider or tax filing process. The add-on's job is to close the gap between "the timesheet photo is in my phone" and "the payroll data is in my sheet, calculated and ready." The output feeds the rest of your payroll workflow — it doesn't replace it.

The Bottleneck Isn't Calculation. It's the Handoffs.

The quickest way to shorten a payroll cycle isn't to calculate faster. It's to eliminate the steps that happen before calculation begins. For a small business processing 20 hourly employees, the pipeline described here replaces roughly 40 minutes of transcription, formula application, and cross-checking per pay period with a batch upload and a computed-column pass that runs in under three minutes. Across 26 biweekly pay periods, that's over 16 hours of recovered time — two full working days a year that return to the business instead of to the keyboard.

But the time savings, while real, isn't the most important outcome. The important outcome is a payroll spreadsheet where every row is self-contained — computed at extraction, not dependent on formula ranges that drift between pay periods. It's a sheet where an auditor can trace a gross pay number back to an extracted hour value and an original timesheet photo in one continuous trail. It's a workflow where the person who runs payroll spends their Wednesday evening doing something other than typing.

Test the pipeline on your own timesheets. Open the demo, upload a timesheet photo, define a computed column, and see if the output looks like a payroll row — because the handoffs between receiving a timesheet and paying an employee shouldn't outnumber the employees on the payroll.