Gusto
Gusto is an HR platform for businesses that helps you with payroll, human resource management, and benefits (such as insurance) all in one place: you enter employee information and the payroll schedule, and the system will automatically calculate gross pay and deductions, generate payslips, track documents, and assist with onboarding steps so the team can get started faster.
- Company set up and details
- People
- Payroll
- Benefits
- Time & Attendance
- Taxes forms and compliance
- Reports
- App directory
Company set up and details
Quick scan
This tab is where you set the rules of the road: who can do what, how your account is protected, and the core company details Gusto uses across People, Payroll, Taxes, and Reports.
- Get the company profile right first (legal name, addresses, tax identifiers you’ll enter during setup).
- Lock down access (admins, approvals, 2-step verification, fraud prevention).
- Know where to find account-level settings vs feature-level settings.
- Keep a simple audit trail: who changed what, and when (via role boundaries + approvals).
1) Purpose / Outcome
Your goal here is to configure the minimum “company truth” that powers everything else: identity, access control, and baseline payroll settings. If you do this cleanly, adding people and running payroll becomes mostly routine.
- Confirm company identity details used across filings and documents.
- Establish admin roles and reporting permissions before inviting others.
- Enable protections (2-step verification, fraud controls) early.
- Set approval expectations so payroll actions aren’t a surprise.
- Know which settings are global vs per-feature (e.g., payroll approvals vs time off approvals).
2) Who this is for + When to use
This tab matters most for Primary admins and anyone responsible for risk, payroll governance, or audits. You typically touch it at setup, then only when something changes (new admin, policy changes, security incident).
- Primary admin setting up the account for the first time.
- Ops/finance lead adding approvals or tightening access.
- Teams adding integrations that require admin authorization.
- Any time you change legal addresses, bank details, or key contacts.
- When someone needs Reports access but not full Payroll access.
3) Where in navigation + Related tabs
In the Help Center IA, this area sits under “Employers and admins” and groups setup, account settings, and admin permissions. It connects directly to People (adding team), Payroll (running pay), and Taxes & Compliance (filings).
4) Mental model / Flow
Think of this tab as “global configuration.” Most items here are prerequisites: they unlock features, reduce risk, and define who can approve or view sensitive data.
- Set company identity + core details (used everywhere).
- Define admin structure (Primary admin + delegated admins/managers).
- Turn on protections (2-step verification, fraud prevention) and confirm access.
- Configure approvals (e.g., payroll approvals) so actions are reviewed.
- Revisit only when people/policies change.
5) Objects & Terms
These are the account-level concepts you’ll see referenced in setup and security articles. Learn them once so you don’t accidentally grant too much access.
- Primary admin: the top-level admin who can manage roles/permissions.
- Admin / Manager / Employee: permission levels that control what’s visible/doable.
- Approvals: review gates for high-impact actions (like payroll approvals).
- 2-step verification: login protection (account settings).
- SOC reports / bridge letters: security assurance artifacts (if available).
6) State machine / Lifecycle
Account setup usually follows a simple lifecycle: initialize → configure → secure → govern → maintain. The exact “setup checklist” varies by company, but the structure stays the same.
- Initialize: create account and choose plan.
- Configure: add company details and baseline payroll info.
- Secure: enable 2-step verification and fraud prevention settings.
- Govern: set roles/permissions and approvals.
- Maintain: periodic review (new admin, policy updates, audits).
7) Core jobs-to-be-done
These are the most common “admin jobs” that belong to account-level setup rather than a specific feature tab.
Invite the right admins
- List who needs access (finance, HR, manager approvers).
- Grant minimum permissions needed.
- Verify Reports access separately from Payroll access.
- Set an owner for ongoing access reviews.
Protect sign-in
- Turn on 2-step verification for admins.
- Document recovery steps for Primary admin.
- Use fraud-prevention settings and monitor changes.
- Keep a small group of trusted admins.
Set approvals
- Decide what needs review (e.g., payroll submissions).
- Assign approvers and backup approvers.
- Test the approval flow with a low-risk change.
- Communicate cutoffs (when data must be final).
8) Happy path workflow #1 — Secure your admin access (6–8 steps)
Do this before you invite a wider team. The point is to make sure your account can’t be easily hijacked and that responsibilities are clear.
- Identify the Primary admin and at least one backup admin (policy, not a shared login).
- Enable 2-step verification for admins in account settings.
- Review fraud-prevention guidance/settings available in account settings.
- Invite additional admins with minimum permissions needed.
- Confirm each admin can sign in successfully and sees only expected tabs.
- Write down who approves payroll actions and how to escalate issues.
9) Happy path workflow #2 — Prepare for clean reporting (6–8 steps)
A lot of “report confusion” is actually permission confusion. Set roles and reporting access intentionally so the right people can self-serve.
- List which reports stakeholders need (payroll, tax, HR/time).
- Grant reporting permissions to the right admin roles (don’t over-grant payroll power).
- Ask a non-primary admin to open Reports and confirm visibility.
- Create a simple “monthly reporting checklist” and assign an owner.
- Decide where official exports live (shared drive) and who can access them.
- Review access quarterly (or when roles change).
10) Decision points (A/B)
Use these common fork-in-the-road decisions to avoid rework. When in doubt, choose the option that reduces access and can be expanded later.
| Situation | If A… | If B… | Do this in Gusto |
|---|---|---|---|
| Someone needs reports only | A: They also run payroll | B: They should not run payroll | Grant reporting permissions; keep payroll permissions minimal. |
| Approvals for payroll | A: Single owner team | B: Multiple reviewers needed | Set payroll approvals and backup approvers (admin permissions area). |
| Account security posture | A: Few admins | B: Many admins | Require 2-step verification and regularly review admin list. |
| Need proof for vendor/security review | A: Internal only | B: External audit/customer request | Request SOC reports/bridge letters (if available) from account settings. |
11) Guardrails — Do/Don’t, common mistakes, roles
These guardrails prevent the most painful admin errors: locked-out accounts, over-broad permissions, and payroll surprises.
Do
- Enable 2-step verification for admins early.
- Keep the Primary admin role stable and documented.
- Use approvals for high-impact actions when supported.
Don’t
- Don’t share logins or make a generic “admin@” user.
- Don’t grant payroll permissions just to let someone see reports.
- Don’t change core company settings without documenting the reason.
Common mistakes (avoid)
- Admins can’t see Reports → missing reporting permissions.
- Primary admin leaves company → no planned handoff.
- Too many admins → unclear accountability and higher risk.
- No approval flow → payroll runs before time/time-off is finalized.
- Security review scramble → SOC/security docs not requested in advance.
12) Proof & Practice — what good looks like, checklists, lab
Use this section to verify you configured the account correctly and to practice one safe change end-to-end.
What good looks like
- Every admin has 2-step verification enabled and can sign in successfully.
- Only the minimum set of people can run payroll; others can view Reports if needed.
- Approval responsibilities are written down and actually used.
- Company details are consistent (no conflicting addresses across records).
- There is a quarterly access review owner.
Checklist: Pre-check
- Primary admin identified and backup admin planned.
- 2-step verification policy decided and enabled.
- Admin list drafted (names + responsibilities).
- Reporting needs mapped to people/roles.
- Approval flow decision documented.
- Security docs needs (SOC/bridge) considered.
Checklist: Post-check
- Each admin can access only the tabs they need.
- Reports access confirmed for non-payroll stakeholders.
- 2-step verification tested on a second device.
- Approvals tested with a low-risk action.
- Owner assigned for quarterly access review.
- Notes saved: who approved what and why.
Practice lab (10 minutes): “Create a safe reporting role”
Goal: give someone access to view/export reports without giving them payroll power. This builds the habit of least-privilege.
- Pick a trusted teammate who needs reports only.
- Invite them with a role/permission set that includes Reports access.
- Have them sign in and navigate to Reports.
- Ask them to download one non-sensitive report export.
- Confirm they cannot run payroll or change bank/tax settings.
- Write down what permissions were granted and why.
People
Quick scan
People is your input hub. If People data is wrong or incomplete, Payroll and Taxes will be wrong too. The fastest way to stay accurate is to standardize how you add, onboard, and change team members.
- Use consistent “add/hire” workflows for employees vs contractors.
- Keep profiles clean (work location, pay type, start dates) before running payroll.
- Use onboarding steps/checklists so required info isn’t missing.
- Track employment changes intentionally (raises, status changes, terminations).
1) Purpose / Outcome
Your outcome is a complete, payroll-ready roster with correct worker type, pay setup, and required onboarding info. When People is maintained, payroll runs become predictable and less error-prone.
- Build a single source of truth for worker identity and classification.
- Collect required details early (start date, work address, pay type).
- Ensure onboarding data is complete before first pay.
- Apply changes (compensation/status) in a controlled way.
- Keep contractors separate from employee workflows where needed.
2) Who is this for + When to use
This tab is for admins and managers who add new hires, maintain profiles, or process changes. You use it whenever someone joins, changes pay/status, or needs profile corrections.
- HR/ops admins adding employees and contractors.
- Managers participating in onboarding or time off approval from People pages.
- Finance/payroll admins ensuring payroll-ready data is accurate.
- Any time a work location or pay rate changes (to avoid tax/withholding issues).
- When converting a contractor to an employee (treat as a new lifecycle).
3) Where in navigation + Related tabs
In the official Help Center IA, People sits under “Employers and admins” and groups hiring/onboarding and worker records. Most People actions feed Payroll and Taxes; reporting validates your setup.
4) Mental model / Flow
People flows from “intent to hire” to “active paid worker.” The key is to collect and validate essentials before the first payroll run so you don’t scramble during payroll.
- Create the worker record (employee or contractor).
- Set compensation basics and start date.
- Send onboarding steps/checklist and collect required info.
- Validate profile (work location, payment method readiness).
- Maintain changes over time (raises, role/status changes, termination).
5) Objects & Terms
These are the People concepts referenced throughout hiring and onboarding guidance. Use them consistently so downstream payroll is consistent.
- Employee profile: the main record for pay, tax, and personal details.
- Contractor: a different worker type with its own add/pay flow.
- Offer letters: documents used during hiring flow (if enabled).
- Onboarding: steps/checklists to collect info before first payroll.
- Employment changes: updates like compensation or status changes.
6) State machine / Lifecycle
A practical lifecycle for People records is: draft → invited/onboarding → active → changed → offboarded. Treat transitions as checkpoints so you don’t pay someone with incomplete data.
- Draft: record created; key fields may be missing.
- Invited / Onboarding: worker is completing onboarding steps.
- Active: eligible to be paid in Payroll runs.
- Changed: compensation/status updates recorded (keep notes).
- Offboarded: terminated/inactive; confirm final pay and documents as required.
7) Core jobs-to-be-done
These jobs map directly to the People hub topics and are the highest leverage tasks for new admins.
Add a new employee
- Use the official add-employee flow when hiring.
- Set start date and pay type correctly.
- Trigger onboarding steps early.
- Verify profile completeness before first payroll.
Add a contractor
- Choose contractor vs employee intentionally (classification matters).
- Collect W-9/contractor details per your process.
- Confirm payment method setup before first payment.
- Keep contractor changes separate from employee changes.
Process an employment change
- Update compensation with an effective date.
- Confirm downstream impact on payroll calculations.
- Document why the change was made.
- Verify the next payroll preview reflects the change.
8) Happy path workflow #1 — Add an employee and make them payroll-ready
This workflow prevents the most common newbie problem: running payroll when the new hire’s profile isn’t complete.
- In People, choose the add-employee flow that matches your situation.
- Enter essentials: legal name, start date, work location, pay type.
- Send onboarding steps (collect required personal/tax info).
- Confirm the employee completes onboarding before payroll cutoff.
- Review the profile for missing fields (addresses, withholding, payment method readiness).
- Run a payroll preview and confirm the employee appears with expected pay.
9) Happy path workflow #2 — Contractor → paid correctly
Contractors usually have fewer fields, but the risk is classification confusion and missing payment readiness. Keep the flow simple and consistent.
- In People, select the contractor path (don’t reuse employee onboarding steps).
- Enter contractor identity and contact details.
- Confirm payment method approach (direct deposit/check as your process).
- Set expected pay pattern (if applicable) so payroll entry is consistent.
- Run the first contractor payment in Payroll with a small test amount if needed.
- Verify the contractor pay history after processing.
10) Decision points (A/B)
Use these decisions to pick the correct People path and avoid downstream corrections.
| Situation | If A… | If B… | Do this |
|---|---|---|---|
| Worker type | A: W-2 employee | B: Contractor | Use the People add flow that matches (employee vs contractor). |
| Onboarding completeness | A: Info complete | B: Info missing | Delay payroll inclusion until onboarding fields are complete. |
| Work location changed | A: Same state/location | B: Different state/location | Update profile first; then re-check Taxes/Compliance requirements. |
| Manager needs time off control | A: Admin handles | B: Manager handles | Assign/confirm manager workflows for time off approvals (where applicable). |
11) Guardrails — Do/Don’t, common mistakes, integrations
People mistakes become payroll mistakes. The guardrails below keep you from paying the wrong person, the wrong amount, or with the wrong compliance setup.
Do
- Standardize your add-employee process.
- Require onboarding completion before first payroll cutoff.
- Audit work locations when someone moves (tax/compliance impact).
Don’t
- Don’t mix contractor and employee onboarding steps.
- Don’t run payroll “hoping the info is fine” — verify profiles first.
- Don’t change compensation without an effective date and a quick payroll preview.
Common mistakes (avoid)
- New hire missing from payroll → profile not payroll-ready.
- Wrong taxes withheld → work location or withholding info outdated.
- Duplicate person records → added twice during rushed onboarding.
- Contractor paid as employee → wrong worker type chosen.
- Changes not reflected → edited after payroll cutoff, not before preview.
12) Proof & Practice — quality bar, checklists, lab
Use this to validate People data quality and practice a clean onboarding loop that feeds Payroll correctly.
What good looks like
- Every active worker has a complete profile (identity, start date, location, pay type).
- New hires complete onboarding before first payroll.
- Contractors are kept in the contractor flow and appear in pay history after payment.
- Employment changes are recorded with effective dates and validated in payroll preview.
- Managers/admins know where to approve time off when enabled.
Checklist: Pre-check
- Worker type decision made (employee vs contractor).
- Start date and work location known.
- Compensation details confirmed (rate/salary).
- Onboarding steps prepared (what you need collected).
- Payroll cutoff date communicated.
Checklist: Post-check
- Profile shows no missing essentials (address/location/pay type).
- Worker appears in payroll preview as expected.
- First payment is visible in pay history after processing.
- Employment change logs/notes saved for future questions.
- Reports can be used to confirm roster/pay outputs.
Practice lab (10–12 minutes): “Onboard one test hire cleanly”
Goal: execute an end-to-end add/onboard loop so the person is ready for payroll without edits during payroll.
- Create a test employee record using the add-employee guidance.
- Populate start date, work location, and compensation basics.
- Send onboarding steps/checklist and mark what’s required.
- Complete onboarding in test (or simulate completion by filling required fields).
- Open Payroll preview and confirm the employee appears correctly.
- Export one report (if available) to confirm People data is reflected.
Official docs links
Payroll
Quick scan
Payroll is where you convert People + Time data into money moved and records created. New admins succeed fastest by using two habits: (1) preview before submitting and (2) reconcile after processing.
- Use “Paying your team” guidance for payment methods and payroll entry.
- Use “Payroll settings” for autopilot, reminders, and approvals.
- Use “Payroll history” to verify outcomes and fix issues.
- When you change pay rules (custom earnings, salary hours), re-check next payroll preview.
1) Purpose / Outcome
Your outcome is a correct payroll run: right people, right amounts, right payment method, and a clean record you can audit later. Payroll should be repeatable on a schedule, not a fire drill.
- Pay employees and contractors using approved payment methods.
- Apply earnings and deductions consistently (including custom earnings if needed).
- Keep payroll settings stable (autopilot/reminders/approvals).
- Use payroll history to verify what happened and correct issues.
- Ensure salaried hours/earnings behavior matches your intent.
2) Who is this for + When to use
This is for payroll admins and reviewers who run payroll, review payroll, or fix payroll issues. You’ll use it every pay period and whenever you need to edit/correct a payroll.
- Payroll admins running regular payroll runs.
- Approvers reviewing payroll before submission (if approvals enabled).
- Finance reconciling after payroll (reports + history).
- Anyone issuing an advance or off-cycle/correction payroll (if applicable).
- Teams auditing prior payments via payroll history.
3) Where in navigation + Related tabs
Payroll sits alongside People (inputs), Time & Attendance (hours/time off inputs), and Taxes & Compliance (filings). Reports are your proof layer for exports and reconciliation.
4) Mental model / Flow
Payroll is a loop: prepare inputs → calculate → review → submit → verify. When something looks off, debug in that order instead of guessing.
- Prepare: confirm People roster and any time/time-off inputs are correct.
- Calculate: enter hours/earnings/deductions as needed.
- Review: check totals and spot anomalies.
- Submit: finalize the payroll run.
- Verify: use payroll history and reports to confirm outcomes.
5) Objects & Terms
Payroll terms show up in settings, payroll entry screens, and reports. Knowing them helps you avoid accidental pay changes.
- Payment methods: ways to pay your team (check/direct deposit/etc).
- Autopilot: automated payroll behavior (settings topic).
- Payroll reminders: calendar reminders to avoid missing cutoffs.
- Custom earnings: additional earning types you define.
- Salaried default hours: hours behavior that can affect wages if edited.
6) State machine / Lifecycle
A payroll run typically moves through: draft → reviewed → submitted → processed → historical record. Your goal is to catch issues before submission, because changes after processing can be more complex.
- Draft: you’re entering hours/earnings/deductions.
- Reviewed: totals checked and approvals completed (if enabled).
- Submitted: payroll finalized.
- Processed: payments issued and payroll becomes part of history.
- History/Audit: review paystubs, journals, and payroll history.
7) Core jobs-to-be-done
New payroll admins should master these jobs first; everything else builds on them.
Run a regular payroll
- Confirm inputs (People + time/time off) before starting.
- Enter hours/earnings carefully.
- Review totals and outliers.
- Submit, then verify in history/reports.
Manage payroll settings
- Configure Autopilot if desired.
- Add calendar reminders for pay dates.
- Set approvals (if your org needs review gates).
- Keep settings changes documented.
Handle special pay items
- Create custom earnings when needed.
- Understand salary hours behavior before editing hours.
- Use reports (payroll journal) to validate year-end info.
- Check deductions (benefits/garnishments) impact on net pay.
8) Happy path workflow #1 — Run your first clean payroll (7–9 steps)
This is the “no surprises” first run: verify inputs, run payroll, then confirm outputs in history and reports.
- Confirm People roster is correct (new hires onboarded).
- Confirm time off approvals/time inputs are ready if you use them.
- Start payroll and enter hours/earnings.
- Add any custom earnings only if required.
- Review totals for outliers (unexpected net pay changes).
- Submit payroll.
- After processing, open payroll history to verify the run exists.
- Download a payroll report (e.g., payroll journal) for reconciliation.
9) Happy path workflow #2 — Adjust a salaried employee cleanly (6–8 steps)
Salaried pay can be tricky if hours edits change wages. Use a careful preview-first approach to avoid accidental pay changes.
- Review the employee’s salaried classification and default hours behavior.
- Decide what should change: rate vs hours vs custom earning.
- If adding a special payment, use an appropriate earning type (custom if needed).
- Run payroll preview and verify wages reflect your intent.
- Submit payroll only after the preview matches expectations.
- Verify in payroll history and save a report for audit.
10) Decision points (A/B)
These decisions prevent the most common payroll mistakes: wrong inputs, wrong method, wrong timing.
| Situation | If A… | If B… | Do this |
|---|---|---|---|
| Time off included in payroll | A: Approved | B: Pending | Approve/resolve requests first; approved time off is processed in payroll. |
| Need a new earning type | A: Standard (bonus/tips) | B: Special case | Create a custom earnings type only when needed. |
| Salaried hours edit | A: Purely time tracking | B: Will affect wages | Know that adjusting salaried hours can adjust wages; preview first. |
| Reconciling year-end info | A: Everything in Gusto | B: Also paid outside Gusto | Report non-Gusto payrolls and use payroll journal report to confirm annual info. |
11) Guardrails — Do/Don’t, common mistakes, permissions
Guardrails keep payroll boring (that’s a compliment). Most issues come from last-minute edits or missing prerequisites.
Do
- Use payroll settings for reminders and repeatability.
- Preview and review before submitting every time.
- Reconcile using reports after processing.
Don’t
- Don’t edit salaried hours casually—wages may change.
- Don’t add custom earnings without knowing how they affect pay/overtime.
- Don’t ignore payroll blockers—fix the cause (often People/tax setup).
Common mistakes (avoid)
- Missing new hire in payroll → People onboarding incomplete.
- Unexpected net pay change → deductions/earning type misapplied.
- Late payroll → no reminders / no cutoff discipline.
- Can’t find historical details → not using payroll history.
- Year-end mismatch → forgot non-Gusto payroll reporting.
12) Proof & Practice — checklists + lab
Use these to ensure your payroll loop is stable and auditable from day one.
What good looks like
- Each payroll run has a clean record in payroll history.
- Exports from Reports match payroll history totals.
- Time off approvals correctly flow into payroll when approved.
- Custom earnings are used sparingly and consistently.
- Salaried edits don’t unintentionally change wages.
Checklist: Pre-check
- People roster verified (new hires complete).
- Time off approvals finalized (if used).
- Any special earnings identified (bonus, custom).
- Payroll settings/reminders in place.
- Approvals lined up (if enabled).
Checklist: Post-check
- Payroll appears in payroll history.
- Paystubs/records exported if needed for finance.
- Reports export saved (payroll journal).
- Outliers documented (why someone’s pay changed).
- Next payroll notes captured (what to fix before next run).
Practice lab (10–12 minutes): “Payroll audit mini-loop”
Goal: practice verifying a payroll run using history + a report export, so you can answer questions fast later.
- Open a recent payroll in payroll history.
- Download one relevant report export from Reports.
- Cross-check totals (gross, deductions, net) at a high level.
- Pick one employee and verify their pay details match expectations.
- Write a short note: what was verified, and where the export is saved.
Benefits
Quick scan
Benefits works best when you treat it like policy + payroll deductions. The two recurring risks are (1) eligibility rules being unclear and (2) deductions not matching what you intended.
- Start from the Benefits hub topics (health insurance, 401(k), benefit deductions).
- Define eligibility consistently (full-time/part-time rules vary; document your company policy).
- Check how deductions flow into Payroll before first run with benefits enabled.
- Use open enrollment and transfer guidance if you’re moving a plan.
1) Purpose / Outcome
Your outcome is a benefits program that is accurate and payroll-aligned: the right people are eligible, enrollments are managed cleanly, and deductions appear correctly in payroll.
- Offer health benefits and manage enrollment lifecycle.
- Set up retirement/financial benefits (where applicable).
- Add benefit deductions (including third-party benefits) when needed.
- Keep eligibility rules consistent (e.g., hours thresholds).
- Ensure payroll reflects the correct deductions every pay period.
2) Who is this for + When to use
This is for admins who set up benefits, manage enrollments, and ensure deductions are correct. You use it at setup, during open enrollment, and whenever an employee becomes eligible or changes elections.
- HR/ops admins managing enrollments and policy changes.
- Payroll admins verifying benefit deductions in payroll runs.
- Teams transferring an existing plan to Gusto or starting new coverage.
- Anyone reviewing eligibility classifications (full-time vs part-time).
- Admins adding third-party benefit deductions.
3) Where in navigation + Related tabs
Benefits ties to People (who is eligible) and Payroll (how deductions apply). Reports help you confirm deductions and costs over time.
4) Mental model / Flow
Benefits is a coordination loop: define eligibility → offer plan → enroll → deduct in payroll → maintain when changes happen.
- Define who is eligible (hours and policy).
- Set up the benefit (health, 401(k), or other).
- Enroll employees during onboarding or open enrollment.
- Confirm payroll deductions appear correctly.
- Maintain: life events, terminations, plan transfers, annual renewals.
5) Objects & Terms
Benefits terms are mostly about eligibility, plan types, and deduction mechanics.
- Eligibility classification: full-time vs part-time rules used for benefits.
- Open enrollment: enrollment period for benefits (health).
- Third-party benefit deductions: deductions you add for benefits not managed directly.
- 401(k): retirement benefit option in the Benefits hub.
- Small-group health insurance: health benefits topic group.
6) State machine / Lifecycle
Benefits administration tends to follow a lifecycle: configured → eligible → enrolled → deducted → changed/terminated. Keep a checklist for each transition so you don’t miss payroll impacts.
- Configured: plan/deduction exists in Benefits.
- Eligible: employee meets your eligibility criteria.
- Enrolled: employee has an active election (health/open enrollment).
- Deducted: payroll run reflects the correct deduction.
- Changed: life event, policy update, or termination triggers update.
7) Core jobs-to-be-done
Focus on these jobs first, because they control most benefits errors and rework.
Set eligibility rules
- Document your company’s full-time/part-time policy.
- Cross-check against general thresholds (e.g., 30+ hours typical for full-time).
- Align eligibility with onboarding steps (tell employees what applies).
- Re-check when employees change hours or status.
Add benefit deductions
- Use the Benefits hub path for third-party deductions.
- Confirm pre-tax vs post-tax behavior with your policy/provider.
- Test one payroll preview to verify deduction amounts.
- Standardize naming so reports are readable.
Manage enrollments
- Follow health benefits/open enrollment guidance.
- Track enrollment deadlines and communicate them.
- Validate new enrollments show expected payroll deductions.
- Update when employment status changes.
8) Happy path workflow #1 — Add a benefit deduction and validate in payroll
This is the simplest reliable loop: add a deduction, preview payroll, and confirm it is behaving before it affects real pay.
- In Benefits, open the area for adding your own benefit deductions.
- Create the deduction with a clear name (include provider or purpose).
- Assign it to the right employees (based on eligibility policy).
- Run a payroll preview and confirm the deduction appears.
- Check net pay changes are expected and documented.
- Submit payroll only when preview looks correct.
9) Happy path workflow #2 — Set eligibility and communicate it (6–8 steps)
Eligibility confusion causes most benefits escalations. This workflow helps you define the rule, apply it consistently, and make it obvious to employees.
- Write a one-sentence eligibility policy (who qualifies and when).
- Validate your policy against general definitions (e.g., 30+ hours typical for full-time).
- List edge cases (part-time, variable hours, new hires).
- Apply eligibility consistently when enrolling employees in benefits.
- Communicate the rule during onboarding (People + onboarding materials).
- Re-check eligibility whenever hours/status change.
10) Decision points (A/B)
These decisions help you choose the right setup path and avoid payroll/eligibility mismatches.
| Situation | If A… | If B… | Do this |
|---|---|---|---|
| Benefit type | A: Health insurance | B: Third-party benefit | Use health benefits guidance vs add your own deduction path. |
| Eligibility status | A: Full-time | B: Part-time | Apply your eligibility policy and confirm it matches typical definitions. |
| Enrollment timing | A: Open enrollment | B: New hire onboarding | Follow open enrollment guidance or onboarding process accordingly. |
| Payroll impact check | A: Preview verified | B: Not verified | Don’t submit payroll until deductions are verified in preview. |
11) Guardrails — Do/Don’t, common mistakes, roles
Benefits errors are costly because they touch employee pay and coverage. Use these guardrails to keep changes controlled.
Do
- Define eligibility clearly and document it.
- Validate deductions in payroll preview before submission.
- Use the hub guidance for health/open enrollment/transfer.
Don’t
- Don’t change deductions mid-cycle without communicating net pay impact.
- Don’t assume part-time employees are ineligible (depends on rules/policies).
- Don’t leave deduction naming ambiguous (hurts reporting).
Common mistakes (avoid)
- Employees enrolled but no deduction → payroll preview not checked.
- Wrong employees deducted → eligibility rule not applied consistently.
- Confusing reports → inconsistent deduction names.
- Open enrollment missed → no calendar/process ownership.
- Eligibility disputes → policy not communicated during onboarding.
12) Proof & Practice — checklists + lab
This helps you confirm benefits are configured correctly and safely before they affect real payroll runs.
What good looks like
- Eligibility rule is documented and consistently applied.
- Benefit deductions match employee elections and appear correctly in payroll.
- Open enrollment/transfer activities have an owner and timeline.
- Reports and payroll exports clearly show deductions by name.
- Employees aren’t surprised by net pay changes (you communicated changes).
Checklist: Pre-check
- Eligibility policy written (hours threshold + exceptions).
- Deduction naming convention decided.
- List of enrolled employees prepared.
- Payroll preview date chosen for validation.
- Communication message drafted for net pay impact.
Checklist: Post-check
- Preview shows deductions correctly for each enrolled employee.
- Edge cases verified (new hires, part-time exceptions).
- First payroll with benefits reconciled via report export.
- Any corrections documented (what changed and why).
- Open enrollment/renewal reminders created.
Practice lab (8–10 minutes): “Eligibility + deduction smoke test”
Goal: confirm your eligibility rule and one deduction behave correctly before real payroll.
- Pick one employee who is clearly eligible per your policy.
- Add or verify one benefit deduction setup.
- Run a payroll preview and confirm the deduction appears as expected.
- Check that an ineligible employee does not receive the deduction.
- Write down the rule + deduction name used (for future audits/reports).
Time & Attendance
Quick scan
Time & Attendance is your “hours truth.” If time tracking or time off approvals are messy, payroll becomes messy. Keep the loop tight: track → review → approve → payroll.
- Time tracking setup includes features like Time Kiosk and location sharing (where available).
- Time off includes policies, requests, and admin/manager review flows.
- Approved time off hours are processed in payroll and balances update accordingly.
- Use statuses (To Review / Approved / Paid) to manage the queue.
1) Purpose / Outcome
Your outcome is clean time data: correct hours, clear approvals, and time off that flows into payroll without manual correction. This reduces payroll errors and employee disputes.
- Track hours reliably (including kiosk options where applicable).
- Set up time off policies (paid/unpaid, limited/unlimited).
- Approve/decline requests using admin/manager flows.
- Ensure approved time off is reflected in payroll.
- Maintain a predictable review cadence before payroll cutoff.
2) Who is this for + When to use
This is for admins, managers, and employees depending on the feature. Admins set policies; managers review requests; employees submit requests and track time (including via mobile where enabled).
- Admins setting time off policies and managing the requests queue.
- Managers approving/declining time off for their team.
- Employees requesting time off (mobile app flow available).
- Payroll admins validating that approved time off is paid.
- Any time you add a time tracking integration or change policies.
3) Where in navigation + Related tabs
Time & Attendance connects directly to Payroll (hours + approved time off become pay inputs) and People (manager/team context). Reports are your proof for audits and reconciliation.
4) Mental model / Flow
Time & Attendance is a pipeline. The key is that approvals happen before payroll runs, so payroll doesn’t become the place where you argue about time.
- Define policies and rules (time off policies; tracking rules).
- Employees track time / submit time off requests.
- Managers/admins review and approve/decline.
- Approved items flow into payroll processing.
- After payroll, statuses move to Paid for the relevant requests.
5) Objects & Terms
These terms appear directly in time off and time tracking docs and screens.
- Time off policy: limited/unlimited, paid/unpaid types.
- Requests queue: To Review / Approved / Paid statuses.
- Record time off: admins can record time off (US employees) from Time off section.
- Time Kiosk: a time tracking mode mentioned in time tracking topics.
- Time/Work tab (mobile): where employees request time off in the app.
6) State machine / Lifecycle
Time off requests have a documented lifecycle that makes reviews predictable.
- To Review: submitted but not decided.
- Approved: approved but not yet paid (payroll not processed for all dates).
- Paid: approved and payroll processed for all requested dates.
- Declined: request rejected with a note to the employee.
- Decline approved request: only possible if payroll hasn’t been processed yet.
7) Core jobs-to-be-done
These are the practical jobs that keep Time & Attendance reliable and payroll-friendly.
Set time off policies
- Create limited or unlimited policies.
- Choose paid vs unpaid and define accrual/limits as needed.
- Know contractors cannot be added to time off policies (per docs).
- Enable requests so approved hours flow into payroll.
Review and decide requests
- Use the Time off section to view requests.
- Approve/decline with a note where helpful.
- Know when declining approved is allowed (before payroll).
- Keep a cutoff rule before payroll runs.
Configure time tracking
- Set up time tracking and confirm how employees clock in/out.
- Decide if you will use Time Kiosk or location sharing.
- If using an integration, validate sync rules and conflicts.
- Test a full day of time entries before payroll.
8) Happy path workflow #1 — Set up time off policies + requests (7–9 steps)
This workflow sets up time off so employees can request, managers can approve, and payroll can process it automatically.
- Open Time & Attendance → Time off.
- Create a policy (limited/unlimited; paid/unpaid).
- Assign eligible employees to the policy.
- Enable time off requests so employees can submit in Gusto and it records into payroll.
- Assign managers to handle requests (or decide admins handle them).
- Have an employee submit a test request (mobile or web).
- Approve it and confirm it shows as Approved in the queue.
- Run payroll and verify it moves toward Paid after processing.
9) Happy path workflow #2 — Review requests weekly (6–8 steps)
This keeps the request queue from piling up and prevents last-minute payroll surprises.
- Open Time & Attendance → Time off and filter to “To Review.”
- Scan upcoming dates and check coverage impact (your internal policy).
- Open each request and review employee balance/context.
- Approve or decline and include a note if declining.
- If edits are needed, edit and save where your workflow supports it.
- Before payroll cutoff, confirm there are no pending requests for the pay period.
10) Decision points (A/B)
These decisions help you manage approvals and avoid conflicts with payroll processing.
| Situation | If A… | If B… | Do this |
|---|---|---|---|
| Who approves requests? | A: Managers | B: Admins | Assign managers or keep admin-handled per policy guidance. |
| Decline after approval? | A: Payroll not processed | B: Payroll processed | Decline approved request only before payroll is processed. |
| Employee requests via mobile | A: Time/Work tab exists | B: Time tab missing | Confirm feature is enabled; otherwise employee should ask employer/admin. |
| Integration with time system | A: Sync enabled | B: Sync disabled | Validate integration settings; some may require disabling time off requests in Gusto. |
11) Guardrails — Do/Don’t, common mistakes, integrations
Time mistakes usually come from unclear policies and late approvals. These guardrails keep the pipeline healthy.
Do
- Enable requests so approved time off records into payroll.
- Review requests on a schedule (weekly) and clear “To Review.”
- Use notes when declining to reduce back-and-forth.
Don’t
- Don’t leave pending requests until payroll day.
- Don’t assume contractors can be added to time off policies.
- Don’t change policy types casually (e.g., unlimited ↔ limited has constraints).
Common mistakes (avoid)
- Requests stuck in To Review → no review cadence.
- Approved request can’t be declined → payroll already processed.
- Employee can’t request time off → feature not enabled.
- Policy deletion blocked → pending requests exist.
- Integration conflicts → duplicate or mismatched time off settings.
12) Proof & Practice — checklists + lab
Use this to confirm your time off pipeline is working and that payroll will pick it up correctly.
What good looks like
- Employees can submit requests and see confirmations (web/mobile).
- Managers/admins can approve and requests move to Approved.
- After payroll, requests move to Paid.
- Policies reflect your intent (limited/unlimited; paid/unpaid).
- No pending requests exist at payroll cutoff for the pay period.
Checklist: Pre-check
- Policies created and assigned.
- Requests enabled for employees.
- Managers assigned (or admin ownership decided).
- Review cadence set (weekly) with cutoff before payroll.
- Integration settings confirmed (if used).
Checklist: Post-check
- At least one request moved through To Review → Approved.
- Approval/decline notes used appropriately.
- Payroll run includes approved time off hours.
- Paid status observed after payroll processing.
- Policy changes documented for future reference.
Practice lab (10–12 minutes): “Request → approve → pay”
Goal: run one end-to-end time off request through the documented statuses.
- Create or verify a time off policy.
- Have an employee submit a request (mobile or web).
- As admin, open Time off → To Review and locate the request.
- Approve the request and confirm it appears under Approved.
- Run payroll for the relevant period and confirm it becomes Paid after processing.
Taxes, forms, and compliance
Quick scan
This area is your “proof and risk” hub: taxes, filings, compliance tasks, and resolving issues. Most problems trace back to setup gaps (registrations, info missing) or changes (new state, new work location).
- Use the Taxes, forms, and compliance hub to find tax payment/filing topics.
- Use State compliance for rules/mandates and state-specific topics.
- Use the Compliance hub for compliance tasks, tools, and filings.
- For year-end readiness, confirm annual tax information and reconcile with reports.
1) Purpose / Outcome
Your outcome is compliance confidence: you can see what Gusto files/pays, what you must do, and how to resolve notices and issues. You should be able to answer “are we compliant?” with evidence.
- Track tax filings and payments handled by Gusto via hub guidance.
- Resolve tax account/filing/payment issues using the tax issue articles.
- Use Compliance hub to view tasks, tools, and filings.
- Understand state compliance rules/mandates relevant to your workforce.
- Be ready for year-end by confirming annual tax information.
2) Who is this for + When to use
This is for admins responsible for filings, compliance tasks, and notices. You use it during setup, whenever you hire in new jurisdictions, and whenever you receive a tax notice.
- Payroll/tax admins monitoring filings and payments.
- Ops leads managing compliance tasks (Compliance hub).
- Teams hiring across states (state compliance impacts).
- Anyone preparing year-end forms and reconciliations.
- Admins fixing tax account/filing/payment issues.
3) Where in navigation + Related tabs
This area depends on People (work location and roster) and Payroll (what was paid). Reports provide exports you’ll use to reconcile and respond to requests.
4) Mental model / Flow
Compliance is a loop: configure → run payroll → file/pay → monitor → resolve. The Compliance hub is your dashboard for tasks and filings.
- Configure tax accounts and company details (setup phase).
- Run payroll to generate tax liabilities and records.
- Use Taxes hub to view filings/payments handled and forms filed.
- Use Compliance hub to see tasks, tools, and filings.
- Resolve issues/notices using tax issue articles and reports exports.
5) Objects & Terms
These concepts show up across the compliance hub and tax articles.
- Tax forms Gusto files: list of federal/state forms filed on your behalf (per hub).
- Tax payments: payments and deposits related to payroll taxes (per hub).
- Compliance tasks: items you must complete to follow government rules.
- State mandates: rules and requirements by state (state compliance hub).
- Annual tax information: year-end confirmations to ensure accurate reporting.
6) State machine / Lifecycle
A practical compliance lifecycle is: setup-ready → active filing → issue detected → resolved → year-end confirmed. Treat “issues” as tickets with evidence.
- Setup-ready: required tax info entered and company setup complete.
- Active filing: taxes/forms processed as payroll runs occur.
- Issue detected: notice, rejected filing, missing registration, etc.
- Resolved: fixes applied; evidence saved (reports, confirmations).
- Year-end confirmed: annual tax info confirmed and reconciled.
7) Core jobs-to-be-done
These jobs keep compliance stable and reduce expensive surprises.
Monitor your Compliance hub
- Open Compliance hub and review tasks/tools/filings.
- Clear tasks with documented ownership.
- Keep notes for anything requiring external action.
- Re-check after major changes (new state, new entity).
Fix tax issues
- Use “fix tax account/filing/payment issues” guidance.
- Gather evidence (notice, report exports, payroll history).
- Validate People and company setup data first.
- Track status until fully resolved.
Prepare for year-end
- Confirm annual tax information using the official checklist.
- Download payroll journal report for cross-checking.
- Report any non-Gusto payrolls if needed.
- Keep exports in a secure shared location.
8) Happy path workflow #1 — Weekly compliance check (6–8 steps)
This workflow helps you catch issues early, before they become urgent notices.
- Open the Compliance hub to view tasks and filings.
- Scan for overdue tasks and assign an owner.
- Review tax payments/filings status via Taxes hub topics.
- Check for changes that may impact compliance (new hires in new states).
- If an issue appears, open the relevant “fix tax issues” guidance and start a ticket.
- Save evidence (report exports) for anything you touched.
9) Happy path workflow #2 — Year-end readiness mini-run (6–9 steps)
This reduces year-end stress by validating that payroll history and records align with annual tax reporting expectations.
- Open the annual tax information confirmation article and follow the steps.
- Confirm People roster completeness (missing people cause missing tax info).
- Identify any payrolls run outside Gusto and record them if needed.
- Download the payroll journal report and cross-check totals.
- Flag mismatches and resolve before final filings.
- Save a reconciliation note (what you checked and where exports are saved).
10) Decision points (A/B)
These decisions keep you compliant when your workforce or operations change.
| Situation | If A… | If B… | Do this |
|---|---|---|---|
| Hiring in a new state | A: Same-state only | B: New state | Review state compliance requirements and update setup before payroll. |
| Tax issue appears | A: Minor data mismatch | B: Filing/payment problem | Use the official “fix tax issues” guidance and gather evidence. |
| Need proof for audit | A: Quick confirmation | B: Detailed reconciliation | Use Reports exports (payroll journal, etc.) for proof. |
| Year-end accuracy risk | A: All payrolls in Gusto | B: Some outside Gusto | Report non-Gusto payrolls as instructed in annual tax confirmation steps. |
11) Guardrails — Do/Don’t, common mistakes, roles
Compliance work is about evidence and process. These guardrails keep you from “fixing” the wrong thing or losing track of what happened.
Do
- Use the Compliance hub as your task dashboard.
- Save report exports as evidence when resolving issues.
- Review state compliance when workforce locations change.
Don’t
- Don’t ignore notices or “minor” filing issues—create a ticket and track it.
- Don’t change core setup data without understanding downstream payroll impact.
- Don’t wait until year-end to reconcile—do a mini-run earlier.
Common mistakes (avoid)
- Hiring in new state without checking mandates.
- Trying to fix filings without pulling the right reports.
- Year-end mismatch because non-Gusto payroll wasn’t recorded.
- Assuming “no news = compliant” instead of checking Compliance hub.
- Not documenting what changed, when, and why (hard to debug later).
12) Proof & Practice — checklists + lab
This makes compliance measurable instead of vibe-based.
What good looks like
- Compliance hub has no unowned tasks; items are tracked to completion.
- Tax filings/payments are understood and evidenced via hub + exports.
- State compliance changes are reviewed when work locations change.
- Year-end confirmation is done with payroll journal cross-check.
- Issues are resolved with a trail of evidence (reports, notes, outcomes).
Checklist: Pre-check
- Compliance hub bookmarked and reviewed weekly.
- Owner assigned for notices/issues queue.
- Exports location decided (secure storage).
- State hiring plan reviewed (if expanding).
- Reporting permissions confirmed for compliance owner.
Checklist: Post-check
- Tasks cleared or assigned with due dates.
- Any tax issue has a ticket + evidence packet.
- Monthly report exports saved (payroll journal, etc.).
- Year-end run completed before deadline season.
- State compliance review done after any location change.
Practice lab (10 minutes): “Compliance evidence packet”
Goal: practice gathering the minimum evidence you’d need to respond to a compliance question or notice.
- Open Compliance hub and pick one visible task or filing item.
- Open Taxes hub and note the related category (payments/forms).
- Download one relevant report export from Reports (e.g., payroll journal).
- Write a 3-line summary: what you checked, what you found, where the export is saved.
- Store the packet in your secure location for future reference.
Reports
Quick scan
Reports is your proof layer. When someone asks “what happened?”, the answer should come from an export, not memory. If Reports isn’t visible, it may be a permissions issue.
- Reports contains payroll, HR, time, and tax data exports.
- If Reports is missing in the left menu, ask your Primary admin for reporting permissions.
- Use report exports to validate annual tax information and payroll journals.
- Use reports to support audits/notices and internal finance reconciliation.
1) Purpose / Outcome
Your outcome is fast, accurate answers backed by exports: payroll journals for accounting, headcount and HR snapshots for ops, and tax-ready exports for compliance.
- Access and export payroll/HR/time/tax data.
- Standardize a monthly report pack for finance and compliance.
- Reduce ad-hoc questions by sharing a consistent source of truth.
- Use exports to verify year-end readiness (payroll journal).
- Ensure the right people have reporting permissions.
2) Who is this for + When to use
Reports is for admins and stakeholders who need evidence: finance, HR ops, tax/compliance owners, and external advisors. You use it after payroll, monthly close, and year-end.
- Finance reconciling payroll and general ledger entries.
- Compliance owners preparing for notices/audits.
- HR ops reviewing headcount/time trends.
- Primary admin granting reporting access.
- Year-end reviewers confirming annual tax info.
3) Where in navigation + Related tabs
Reports is downstream of everything: People + Payroll + Time & Attendance + Taxes. It’s also a permissions-sensitive area controlled by admin settings.
4) Mental model / Flow
Reports is a pipeline: pick the question → choose the right report → export → store → reference. The key is consistency: the same report pack every period.
- Identify the question (payroll totals, tax info, headcount, time off).
- Open Reports and select the matching report.
- Customize fields/filters if supported.
- Export and store in your agreed location.
- Use exports as evidence for reconciliation/notices/year-end.
5) Objects & Terms
Reports terms are simple: where you find them and why they matter.
- Reports section: left-nav area for viewing and downloading data.
- Reporting permissions: access controlled by Primary admin permissions.
- Payroll journal report: used to cross-check annual tax information.
- Payroll/HR/Time/Tax data: major report categories.
- Export: downloaded file used for reconciliation and proof.
6) State machine / Lifecycle
Reports usage is cyclical: per-payroll and per-month, plus an annual cycle for year-end. Treat each cycle as a checklist so you don’t miss exports.
- Per payroll: export a payroll proof set after processing.
- Monthly close: export summary reports and reconcile.
- Quarterly: prepare compliance snapshots as needed.
- Annual: confirm annual tax information with payroll journal.
- Ad hoc: use exports to respond to notices/audits quickly.
7) Core jobs-to-be-done
These jobs help you become fast and reliable with reporting.
Build a report pack
- Choose 3–5 core reports your org needs.
- Define cadence: per payroll + monthly close.
- Set owners and storage location.
- Keep naming consistent for easy searching.
Fix missing access
- If Reports isn’t visible, request reporting permissions.
- Ask the Primary admin to grant appropriate access.
- Verify access by opening and exporting a small report.
- Document who has access and why.
Support year-end
- Use payroll journal to cross-check annual info.
- Store exports securely for auditors/advisors.
- Reconcile discrepancies early.
- Keep an evidence note per export set.
8) Happy path workflow #1 — Post-payroll reconciliation (6–8 steps)
This workflow creates a reliable audit trail right after a payroll run.
- Confirm payroll processed in payroll history.
- Open Reports and select a payroll report to export.
- Export and store it in your finance folder.
- Spot-check totals vs payroll history summary.
- Note any outliers (big changes) and the reason.
- Share the export (or summary) with stakeholders as needed.
9) Happy path workflow #2 — Fix “I can’t see Reports” (6–7 steps)
This is a common newbie issue and is usually a permissions problem, not a bug.
- Confirm Reports is missing from left navigation.
- Identify your role (admin vs primary admin).
- Ask the Primary admin to grant reporting permissions.
- Log out/in and re-check navigation.
- Open Reports and export one small report as a test.
- Document the access change (who granted it and why).
10) Decision points (A/B)
Use these decisions to choose the right reporting workflow and avoid over-sharing data.
| Situation | If A… | If B… | Do this |
|---|---|---|---|
| Data needed | A: Payroll totals | B: Tax/compliance proof | Export payroll reports vs year-end/compliance evidence exports. |
| Access constraints | A: Reports visible | B: Reports missing | Request reporting permissions from Primary admin. |
| Sharing exports | A: Internal stakeholders | B: External advisor/audit | Share minimum necessary; keep storage secure and track what was shared. |
| Frequency | A: Every payroll | B: Monthly only | Prefer per-payroll minimal pack + monthly close pack for fewer surprises. |
11) Guardrails — Do/Don’t, common mistakes, roles
Reports is sensitive data. Guardrails here are about permissions and consistent evidence practices.
Do
- Use Reports for exports instead of manual screenshots.
- Keep a stable report pack and naming convention.
- Grant reporting permissions intentionally.
Don’t
- Don’t over-share exports to people who don’t need them.
- Don’t rely on memory for numbers—export and reference.
- Don’t ignore missing Reports access; fix permissions.
Common mistakes (avoid)
- Reports missing → not granted reporting permissions.
- Exports inconsistent → no standard report pack.
- Audit scramble → exports not saved over time.
- Confusing fields → no naming convention.
- Data leakage risk → exports stored in insecure locations.
12) Proof & Practice — checklists + lab
This builds a repeatable reporting habit: export, verify, store, and reuse.
What good looks like
- Reports exports exist for every payroll and monthly close.
- Permissions are least-privilege (Reports access without extra payroll power).
- Year-end checks reference payroll journal export.
- Exports are searchable and consistently named.
- Stakeholders get answers quickly with evidence, not guesses.
Checklist: Pre-check
- Reports is visible in nav (permissions confirmed).
- Storage location and naming scheme decided.
- Core report pack selected (3–5 reports).
- Owners assigned (per payroll / monthly).
- Sharing rules established (internal vs external).
Checklist: Post-check
- Exports saved for latest payroll.
- Quick reconciliation done vs payroll history.
- Outliers annotated (what changed and why).
- Year-end pack scheduled (mid-year check).
- Access review scheduled quarterly.
Practice lab (8–10 minutes): “Build a 3-report pack”
Goal: create a tiny report pack you can reuse every payroll.
- Open Reports in your admin account.
- Pick three reports you’ll need most (payroll + tax + time/HR).
- Export each and save with a consistent naming scheme.
- Write one note: what each report answers.
- Share the note with stakeholders (not necessarily the raw exports).
Official docs links
App directory
Quick scan
Integrations save time—but only if you pick a clear source of truth. Start with the overview, then choose categories that match your workflow (accounting, hiring, time tracking, etc.).
- Start with “About integrations” and the app directory overview.
- Browse “Integration categories” to find tools by use-case (accounting, banking, hiring, etc.).
- Some setups include API integrations topics.
- Validate time-off/time-tracking behavior when integrating time systems.
1) Purpose / Outcome
Your outcome is a stable sync that reduces manual work without creating data conflicts. A “good integration” has clear ownership of data fields and predictable sync timing.
- Connect Gusto with tools for accounting, hiring, time tracking, and more.
- Use the app directory to find supported integrations.
- Understand integration options including API integrations (where relevant).
- Keep a clear “system of record” for each field (hours, time off, employee data).
- Document who owns troubleshooting and vendor escalation.
2) Who is this for + When to use
This tab is for admins who connect Gusto to other systems. Use it during initial setup, when switching tools, or when troubleshooting sync issues.
- Admins setting up accounting, HR, hiring, or time tracking connections.
- Payroll admins ensuring time and deductions flow correctly.
- Ops teams standardizing onboarding/hiring systems with Gusto.
- Technical teams exploring API integrations.
- Anyone troubleshooting a specific integration setup.
3) Where in navigation + Related tabs
Integrations touch many modules. The most common are Payroll (hours/deductions/accounting exports), People (roster sync), and Time & Attendance (time systems).
4) Mental model / Flow
Integrations are a contract: which system owns which data, and how updates flow. Start with a small scope, test, then expand.
- Pick the integration category that matches your need.
- Read the integration overview and requirements.
- Connect and authorize access (admin permissions may apply).
- Map fields or confirm what data syncs (people, hours, deductions, etc.).
- Test with a small dataset (one employee, one payroll cycle).
5) Objects & Terms
These terms appear in App directory navigation and integration guides.
- App directory: catalog of supported integrations.
- Integration categories: groupings like accounting, banking, hiring, etc.
- About integrations: overview + concepts (including API integrations).
- API integrations: integration approach referenced in About integrations.
- Field mapping: how accounts/fields map (e.g., accounting mappings).
6) State machine / Lifecycle
A safe integration lifecycle is: discover → connect → test → monitor → adjust → (optional) disconnect. Treat disconnect as a planned event to avoid data gaps.
- Discover: choose from integration categories.
- Connect: authorize and configure settings (per integration guide).
- Test: validate one small case end-to-end.
- Monitor: watch for sync errors and conflicts.
- Disconnect: follow provider steps and confirm what stops syncing.
7) Core jobs-to-be-done
These jobs cover 90% of integration success: correct selection, correct mapping, correct validation.
Pick the right integration
- Start from Integration categories by use-case.
- Confirm the integration supports the workflow you need (e.g., hiring, tax prep).
- Identify what data it will sync (people, hours, accounting).
- Decide the source of truth per field.
Configure mappings (accounting)
- Understand account mapping options before syncing.
- Keep mapping names consistent with your chart of accounts.
- Test export results in Reports after first payroll.
- Document mapping decisions for future admins.
Validate time system behavior
- If integrating time tools, confirm time off request settings.
- Test one pay period’s worth of hours sync.
- Confirm approvals happen in the correct system.
- Have a rollback plan (disconnect steps).
8) Happy path workflow #1 — Choose and connect an integration (6–9 steps)
This workflow reduces risk by forcing selection → understanding → controlled connection → test.
- Open Integration categories and select your use-case (e.g., accounting, hiring).
- Read the “About integrations” overview for prerequisites.
- Confirm the integration is compatible with your workflow (fields and sync scope).
- Connect/authorize as an admin and complete setup steps.
- Run a small test (one employee or one payroll cycle).
- Verify outcomes in the relevant tab (People/Payroll/Reports).
9) Happy path workflow #2 — Troubleshoot a time integration conflict (6–10 steps)
Time integrations often fail when both systems try to own time off or hours. Use a structured approach: identify owner → align settings → retest.
- Identify which system is the source of truth for time off requests.
- Check integration guidance for required settings (example: some require disabling time off requests in Gusto).
- Confirm time off policies exist and match across systems if required.
- Run a test request and confirm it lands in the correct approval queue.
- Run a small payroll preview to ensure hours/time off flow correctly.
- If unresolved, disconnect and revert, then escalate to the vendor.
10) Decision points (A/B)
Use these decisions to avoid sync conflicts and messy rollouts.
| Situation | If A… | If B… | Do this |
|---|---|---|---|
| Integration goal | A: Accounting export | B: Hiring/time workflow | Choose the correct category first (accounting vs hiring/time). |
| Field ownership | A: Gusto owns people data | B: External system owns | Define source of truth and avoid two-way edits without rules. |
| Time off ownership | A: Gusto requests | B: External requests | Align settings (may require disabling Gusto requests) based on integration guide. |
| Rollout scale | A: Test with 1–2 people | B: Roll out to all | Always test first; verify in Reports after one cycle. |
11) Guardrails — Do/Don’t, common mistakes, permissions
Integrations can create silent errors. Guardrails here are about scoping, testing, and avoiding dual ownership.
Do
- Start with the integration overview and prerequisites.
- Test with a small subset before full rollout.
- Validate outcomes using Reports after first cycle.
Don’t
- Don’t allow two systems to edit the same field without rules.
- Don’t ignore time off conflicts—decide one owner.
- Don’t skip documenting mappings (accounting) and sync scope.
Common mistakes (avoid)
- Wrong integration chosen → didn’t start from categories.
- Sync conflicts → no source-of-truth decision.
- Time off duplicated → both systems accepting requests.
- Accounting exports unusable → mapping not planned.
- Can’t troubleshoot → no test case or documentation saved.
12) Proof & Practice — checklists + lab
This helps you launch integrations safely and keep them stable.
What good looks like
- Integration category and purpose documented (why it exists).
- Source-of-truth defined per major field (people, hours, time off, accounting).
- One successful test case recorded and repeatable.
- Reports exports confirm outcomes after the first full cycle.
- Disconnect plan exists if something breaks.
Checklist: Pre-check
- Integration chosen from categories.
- Prerequisites reviewed (About integrations).
- Source-of-truth decisions written.
- Test plan defined (who, what cycle, what to verify).
- Rollback/disconnect plan noted.
Checklist: Post-check
- Test case succeeded and documented.
- Reports export validates results.
- Time off/time tracking behavior confirmed (no duplicates).
- Mappings saved (if accounting).
- Owner assigned for ongoing monitoring and vendor escalation.
Practice lab (8–10 minutes): “Integration scope doc”
Goal: produce a one-page scope note that prevents future confusion and makes troubleshooting fast.
- Choose one integration category you plan to use.
- Write: purpose, owner, and what data it syncs.
- Decide source of truth for 3 fields (e.g., employee name, hours, time off).
- Add a test checklist: what you will verify in Reports after the first run.
- Add a rollback note (how to disconnect and what stops syncing).
