Rippling

1) Quick scan + Orientation

2) Mental model / Flow

HRIS is the ‘source of truth’ for people and org data. If HRIS fields are incomplete or inconsistent, workflows, payroll, access, and reporting will be noisy and error-prone.

1. Define your core data model (fields + controlled vocabularies).
2. Migrate employees (import or manual entry) and validate correctness.
3. Establish ownership and edit rules for each field (who can change what).
4. Set onboarding inputs (forms/tasks) so new records are complete at creation.
5. Use workflows/policies to enforce rules and reduce manual clean-up.
6. Monitor data quality with a recurring report/check.

3) Objects & Terms

Core HRIS terms you’ll use across Rippling.

4) State machine / Lifecycle

Most HRIS work follows the employee lifecycle; keep transitions explicit.

5) Core jobs-to-be-done

Prioritize jobs that improve data quality and reduce rework.

• Define required fields and controlled lists (departments, locations, levels).
• Import employees and resolve duplicates or missing critical fields.
• Create a consistent onboarding intake (who provides what, by when).
• Set manager/reporting structure to support approvals and access control.
• Standardize naming conventions for titles, teams, and locations.
• Create a recurring data-quality review routine (weekly or monthly).

6) Happy path workflow #1

Workflow: build a ‘New employee record completeness’ routine (before onboarding starts).

1. Pick the minimum required fields for activation (start date, manager, location, type).
2. Create a checklist of missing fields per person.
3. Notify the owner (HR admin or recruiter) when any required field is missing.
4. Block downstream steps (e.g., access provisioning) until fields are complete.
5. Have a manager confirmation step for reporting line and department.
6. Run on a small set of upcoming hires first; expand once stable.

7) Happy path workflow #2

Workflow: manage an internal transfer (department/manager/location) in a controlled way.

1. Create a transfer request form (employee, effective date, new manager/team/location).
2. Route approvals: current manager → new manager → HR.
3. Update the employee attributes on the effective date (not immediately).
4. Trigger downstream tasks (IT access review, payroll/tax updates, reporting changes).
5. Notify stakeholders (employee, managers, payroll, IT) with the effective date.
6. Review outcomes after the date: confirm access/payroll align with the new attributes.

8) Decision points

Choose patterns that keep your HRIS clean as you grow.

9) Guardrails: Do / Don’t & Common mistakes

Treat HRIS like a database: clean inputs, controlled edits, and predictable outputs.

10) What good looks like + Checklists

If HRIS is healthy, other modules get dramatically easier.

11) Practice lab (5–15 min) + Official docs links

Practice: create a mini data-quality audit for a small team (safe and quick).

1. Pick 5–10 employees as your test group.
2. Choose 4 required fields to audit (manager, location, department, type).
3. Check each record and note missing/incorrect values.
4. Fix the values and record who made the change (for accountability).
5. Create a simple ‘data quality’ checklist you can reuse monthly.
6. Share the checklist with the stakeholders who own those fields.

1) Quick scan + Orientation

2) Mental model / Flow

Recruiting is a funnel: requisition → candidates → stages → offer → hire. The key newbie win is building a predictable handoff so every hire arrives in HRIS with complete, usable data.

1. Open a requisition with clear role requirements and owner(s).
2. Source candidates into the pipeline and capture structured data.
3. Move candidates through stages with consistent evaluation criteria.
4. Create an offer and confirm start date + essential onboarding details.
5. Convert the hired candidate into an HRIS-ready record (handoff).
6. Kick off onboarding workflows and tasks (IT, payroll, manager prep).

3) Objects & Terms

Recruiting objects usually map cleanly into HRIS once hired.

4) State machine / Lifecycle

If your docs don’t expose a formal lifecycle, use this simple one.

5) Core jobs-to-be-done

Focus on jobs that reduce cycle time and increase handoff quality.

• Create repeatable requisition templates by department/role type.
• Define pipeline stages and what information is required at each stage.
• Track candidate status and ensure timely feedback loops.
• Generate a complete handoff packet for HRIS (start date, manager, location, type).
• Automate post-offer tasks (checks, forms, device request, payroll prerequisites).
• Measure funnel conversion and identify bottlenecks.

6) Happy path workflow #1

Workflow: open a new requisition with consistent approvals and inputs.

1. Use a requisition template (role, department, location, hiring manager).
2. Confirm budget/headcount owner and route approval to them.
3. Define the pipeline stages for this requisition (keep it consistent).
4. Set stage exit criteria (what must be documented to advance).
5. Publish the role and assign recruiting tasks/owners.
6. Start weekly check-ins: pipeline health, blockers, next actions.

7) Happy path workflow #2

Workflow: convert an accepted offer into a ‘ready-to-onboard’ handoff.

1. Confirm offer acceptance and lock the start date.
2. Collect the handoff packet fields (manager, department, location, employment type).
3. Trigger onboarding kickoff: HR tasks + manager tasks + IT request.
4. Notify payroll/finance of any compensation inputs needed for setup.
5. Set an internal deadline (e.g., 3–5 business days before start date) for completion.
6. Run a final completeness check before day 1.

8) Decision points

Small recruiting choices can create big downstream pain (or savings).

9) Guardrails: Do / Don’t & Common mistakes

The best recruiting system is boring: consistent stages, clear ownership, and clean handoffs.

10) What good looks like + Checklists

Recruiting is ‘good’ when the pipeline is predictable and the handoff is complete.

11) Practice lab (5–15 min) + Official docs links

Practice: design a handoff packet and test it with one recent hire (or mock hire).

1. Write the minimum handoff packet fields (start date, manager, location, type, title).
2. Pick a single requisition and map where each field is captured.
3. Identify one field that’s often missing and add a required step to capture it.
4. Run a mock ‘offer accepted’ scenario and fill the packet end-to-end.
5. Have HR/IT/payroll review the packet for usability.
6. Update the packet and share the final checklist with hiring managers.

1) Quick scan + Orientation

2) Mental model / Flow

Benefits administration is a set of time-bound windows and change events. You’re managing (1) eligibility, (2) plan options, (3) enrollment choices, and (4) payroll/tax deductions that must stay aligned.

1. Confirm HRIS attributes that drive eligibility (location, employment type, hours).
2. Set plan options and who is eligible for each option.
3. Define enrollment windows and required employee actions.
4. Collect elections and validate completeness (dependents, waivers, etc.).
5. Sync deductions and verify payroll reflects elections correctly.
6. Handle change events (new hires, life events) with a consistent process.

3) Objects & Terms

Keep these terms consistent across communications and reporting.

4) State machine / Lifecycle

Benefits are inherently lifecycle-driven (windows + events).

5) Core jobs-to-be-done

Choose jobs that prevent downstream payroll surprises.

• Define eligibility rules using stable HRIS attributes (avoid free-text logic).
• Publish plan options and enrollment instructions clearly.
• Run open enrollment with reminders and completion tracking.
• Process new hire enrollments on a predictable schedule.
• Handle mid-year changes through a consistent ‘event’ workflow.
• Validate payroll deduction alignment before and after effective dates.

6) Happy path workflow #1

Workflow: run open enrollment as a structured campaign (not a scramble).

1. Lock eligibility rules and plan options before announcing dates.
2. Set the enrollment window dates and communicate expectations to employees.
3. Launch enrollment and send reminders to those not complete.
4. Create a help channel/office hours for questions (limit one source of truth).
5. Close the window and run a completeness check (missing elections/waivers).
6. Verify payroll deduction mapping with a sample group before the effective date.

7) Happy path workflow #2

Workflow: process a qualifying life event (mid-year change) with guardrails.

1. Employee submits an event request with the event type and date.
2. Collect required documentation (if your policy requires it).
3. Approve/deny based on eligibility and timing rules.
4. Open a limited change window for that employee only.
5. Update elections and confirm effective date of the change.
6. Verify the next payroll reflects updated deductions correctly.

8) Decision points

These decisions determine how chaotic (or calm) benefits season feels.

9) Guardrails: Do / Don’t & Common mistakes

Benefits mistakes show up as payroll errors or employee trust issues—guardrail them early.

10) What good looks like + Checklists

Benefits is ‘good’ when people can enroll easily and payroll always matches elections.

11) Practice lab (5–15 min) + Official docs links

Practice: run a mini ‘benefits readiness’ audit for 10 employees before open enrollment.

1. Pick 10 employees across different locations/types (to test eligibility rules).
2. Check whether each has complete eligibility fields in HRIS.
3. Simulate what plan options each person should see (write expected results).
4. Identify mismatches and fix the underlying HRIS attribute or rule.
5. Write a one-page checklist for open enrollment launch day.
6. Share the checklist with HR + payroll stakeholders.

1) Quick scan + Orientation

2) Mental model / Flow

Time tracking is a pipeline: capture → validate → approve → export to payroll. If you fail early (capture/validation), the pain shows up at payroll cutoff.

1. Define time policies (who tracks time, rules, rounding/breaks expectations).
2. Collect time entries (clock-in/out or timesheet submission).
3. Validate entries (missing shifts, overlaps, outliers).
4. Route approvals (manager approvals by deadline).
5. Lock the period and mark it payroll-ready.
6. Send approved hours to payroll and verify payouts.

3) Objects & Terms

These terms help you explain the process to managers and employees.

4) State machine / Lifecycle

Time flows in repeating cycles aligned to payroll periods.

5) Core jobs-to-be-done

Keep jobs centered on avoiding payroll cutoff emergencies.

• Set time policies and communicate them clearly to employees/managers.
• Collect time consistently and reduce manual corrections.
• Route approvals with clear deadlines and reminders.
• Catch exceptions early (missing time, outliers, overlaps).
• Produce payroll-ready data and reconcile with expected hours.
• Maintain an audit trail for changes and approvals.

6) Happy path workflow #1

Workflow: weekly time collection and approval (simple, repeatable).

1. Publish the week’s time policy reminder (deadline + expectations).
2. Employees submit time by a set day/time (e.g., end of last shift or weekly cutoff).
3. System flags missing timesheets and notifies employees early.
4. Managers approve or request corrections by the approval cutoff.
5. Run a final exception report (missing approvals, outliers) before lock.
6. Lock the week and mark it payroll-ready.

7) Happy path workflow #2

Workflow: handle a time correction after lock (exception path).

1. Employee requests a correction with date/time and reason.
2. Manager reviews and approves/denies the correction request.
3. Admin unlocks only what’s necessary (or applies an adjustment entry).
4. Correction is applied with a note/audit trail.
5. Manager re-approves the updated entry if required by policy.
6. Payroll reconciliation is updated and documented.

8) Decision points

Pick the approach that best fits your operational reality.

9) Guardrails: Do / Don’t & Common mistakes

Time data becomes money—protect it with simple controls.

10) What good looks like + Checklists

You’ll know it’s working when payroll isn’t a fire drill.

11) Practice lab (5–15 min) + Official docs links

Practice: create an exception checklist and run it on one pay period (real or test).

1. Choose one recent pay period (or a small test group).
2. List 5 exception rules (missing submission, missing approval, >12h/day, overlaps, weekend work).
3. Check which employees trigger each exception and why.
4. Decide the action for each exception type (fix, approve with note, deny).
5. Run the same checklist again after fixes to confirm exceptions drop.
6. Save the checklist and schedule it as a standard pre-payroll step.

1) Quick scan + Orientation

2) Mental model / Flow

IT in Rippling is a lifecycle engine: it uses HRIS attributes (who the person is) to grant app access and manage devices. The goal is fast onboarding with strong guardrails—and clean offboarding with minimal risk.

1. Define identity and access model (roles/groups → apps/permissions).
2. Connect key apps and identity providers through integrations.
3. Set device standards (models, policies) and inventory tracking.
4. Automate onboarding: create accounts, assign groups, request/assign devices.
5. Automate offboarding: disable accounts, revoke access, collect devices.
6. Monitor posture: access hygiene, device compliance, and exceptions.

3) Objects & Terms

These terms help align HR, IT, and security on the same language.

4) State machine / Lifecycle

Most IT operations map to join/change/leave events.

5) Core jobs-to-be-done

Start with the jobs that reduce security risk and manual tickets.

• Create access groups for common roles and map required apps to each group.
• Connect key business apps so provisioning can be automated.
• Standardize device inventory and assignment process.
• Automate onboarding: access provisioning + device request + task routing.
• Automate offboarding: immediate access removal + device recovery steps.
• Run access hygiene and device posture checks on a cadence.

6) Happy path workflow #1

Workflow: automated onboarding (accounts + access + device).

1. Ensure HRIS has required onboarding fields (start date, role, department, manager).
2. Map the role/department to an access group (apps + permissions bundle).
3. Trigger provisioning at a consistent point (e.g., ‘ready-to-onboard’).
4. Create tasks: device request/assignment and any required setup steps.
5. Notify the manager with day-1 checklist (what the employee needs).
6. Verify access works for the new hire using a test checklist (critical apps).

7) Happy path workflow #2

Workflow: secure offboarding (revoke access first, then recover assets).

1. Record the end date and identify systems with privileged access.
2. Revoke access groups and disable accounts on the end date/time.
3. Invalidate sessions and remove app access (where applicable via integrations).
4. Create device recovery tasks with shipping/return instructions and owner.
5. Notify stakeholders (manager, HR, security) of completion status.
6. Run a post-offboarding audit: confirm no active access remains.

8) Decision points

Make these choices explicit so onboarding/offboarding stays predictable.

9) Guardrails: Do / Don’t & Common mistakes

IT guardrails are mostly about least privilege and clear ownership.

10) What good looks like + Checklists

IT is ‘good’ when onboarding is fast and offboarding is provably complete.

11) Practice lab (5–15 min) + Official docs links

Practice: build an access group for one role and validate onboarding/offboarding behavior.

1. Pick one common role (e.g., Sales Rep) and list 5 required apps.
2. Create an access group definition and note who approves membership changes.
3. Connect (or simulate) the apps needed for provisioning actions.
4. Assign a test user to the group and verify access in those apps.
5. Remove the test user from the group and verify access is revoked.
6. Write a 1-page runbook: how to add/remove someone and how to troubleshoot.

1) Quick scan + Orientation

2) Mental model / Flow

Payroll is an execution pipeline that depends on clean inputs. The newbie trick is making a repeatable pre-check → run → post-check routine, so payroll is a process—not an emergency.

1. Confirm pay schedule and who is in each pay group.
2. Audit upstream changes (new hires, compensation changes, terminations).
3. Validate time/benefits inputs that affect net pay.
4. Preview payroll totals and investigate outliers.
5. Submit/pay payroll (and handle approvals if your org requires them).
6. Reconcile results and document issues for next cycle.

3) Objects & Terms

Payroll vocabulary you’ll use in every pay cycle.

4) State machine / Lifecycle

Payroll runs repeat; consistency is your friend.

5) Core jobs-to-be-done

Keep payroll boring: fewer surprises, more repeatable checks.

• Set pay schedules and keep pay groups clearly defined.
• Ensure new hires and terminations are recorded with correct effective dates.
• Validate time and deductions inputs before previewing payroll.
• Run payroll preview and investigate anomalies (net pay shifts, missing earnings).
• Execute payroll and maintain a clean audit trail of changes.
• Reconcile and report totals after completion.

6) Happy path workflow #1

Workflow: run a standard payroll cycle with a checklist and anomaly review.

1. Lock the pay period cutoff for time submission and approvals.
2. Audit HR changes: hires, comp changes, transfers, terminations (effective dates).
3. Validate benefits/deductions updates that impact this period.
4. Run a payroll preview and scan for outliers (large deltas, missing entries).
5. Resolve anomalies and re-preview until totals look right.
6. Submit payroll and record approvals/notes for any exceptions.

7) Happy path workflow #2

Workflow: handle an off-cycle payroll run (carefully and auditable).

1. Define the reason (correction, bonus, termination payout, etc.) and scope.
2. Identify impacted employees and the specific adjustment amounts.
3. Confirm approvals (finance/HR) before running the off-cycle.
4. Run the off-cycle preview and validate the adjustments only affect the scoped group.
5. Submit the off-cycle and document the event for audit/reconciliation.
6. Update your process to prevent repeat causes (root-cause fix).

8) Decision points

These decisions determine how much payroll depends on heroics.

9) Guardrails: Do / Don’t & Common mistakes

Payroll errors damage trust fast—use guardrails that prevent avoidable mistakes.

10) What good looks like + Checklists

Payroll is ‘good’ when runs are predictable and easy to explain.

11) Practice lab (5–15 min) + Official docs links

Practice: run a ‘payroll readiness’ audit using only 10 employees (safe, fast).

1. Pick 10 employees across different pay scenarios (hourly/salaried, new hire, etc.).
2. Check HRIS: title, manager, location, employment type, effective dates.
3. Check Time & Attendance: submissions and approvals (if used).
4. Check benefits/deductions: any recent changes that affect this pay period.
5. List anomalies and assign owners (HR vs manager vs payroll).
6. Re-check after fixes and record what prevented each issue.

1) Quick scan + Orientation

2) Mental model / Flow

Spend management is a control loop: policy sets rules, capture collects proof, approvals enforce rules, and reporting reconciles outcomes. The win is consistency and low friction.

1. Define policy (limits, categories, required receipt rules).
2. Capture spend (expense submissions and card transactions).
3. Route approvals based on employee attributes and thresholds.
4. Enforce policy (flag violations and request fixes).
5. Reimburse or settle spend and post to accounting.
6. Reconcile and report (monthly close routine).

3) Objects & Terms

Spend terms you’ll use when communicating policy.

4) State machine / Lifecycle

Spend flows from capture to close; keep the loop predictable.

5) Core jobs-to-be-done

Do these jobs well and you’ll avoid the ‘end-of-month scramble’.

• Define clear spend policies with limits, categories, and receipt rules.
• Set approval routing that matches your org structure and thresholds.
• Ensure submissions are complete (proof, category, business purpose).
• Process reimbursements/settlements quickly with predictable SLAs.
• Integrate with accounting where needed and keep mappings documented.
• Run a monthly close checklist and track exceptions.

6) Happy path workflow #1

Workflow: employee submits an expense and it gets approved quickly (happy path).

1. Employee captures expense details and attaches required proof.
2. System validates required fields (category, amount, date, business purpose).
3. Approval routes to manager (and finance if above threshold).
4. Approvers review policy alignment and approve/return for fixes.
5. Finance performs a final check (if needed) and marks as settled.
6. Expense is ready for reporting/accounting with consistent coding.

7) Happy path workflow #2

Workflow: handle a policy exception (missing receipt / out-of-policy spend).

1. Submission is flagged as an exception (missing proof or policy violation).
2. Employee is notified with the exact missing item or rule violated.
3. Employee submits the missing proof or requests an exception approval.
4. Approver decides (approve exception with note, or reject).
5. Finance records the resolution (reason + approver) for audit.
6. Exception trends are reviewed and policy/training updated.

8) Decision points

Decide your control vs speed tradeoffs upfront.

9) Guardrails: Do / Don’t & Common mistakes

Spend systems fail when rules are unclear or enforcement is inconsistent.

10) What good looks like + Checklists

Spend is ‘good’ when it’s fast for employees and predictable for finance.

11) Practice lab (5–15 min) + Official docs links

Practice: create a simple spend policy and run an exception review on a small set of expenses.

1. Draft a 1-page spend policy with 3 thresholds and 5 categories.
2. Pick 10 recent expense submissions (or mock ones) and classify them.
3. Flag which ones need receipts and which are out-of-policy.
4. Write the exact message you’d send to request missing info (template).
5. Summarize the exception rate and the top 1–2 causes.
6. Update your policy doc or training note to reduce those causes.

1) Quick scan + Orientation

2) Mental model / Flow

Global work is mostly about choosing the correct legal/employment model, then running a predictable data + pay process. The easiest way to fail is to treat global like domestic and ‘figure it out later’.

1. Decide the global hiring model per country (EOR, entity payroll, contractor).
2. Collect required worker info and documentation for that model.
3. Create the worker record in your core system with complete attributes.
4. Kick off onboarding tasks and access provisioning through workflows.
5. Run pay cycles with a tight checklist and country-specific validations.
6. Review compliance and classification decisions periodically.

3) Objects & Terms

Use these terms consistently when discussing global hiring.

4) State machine / Lifecycle

Global employment adds more states because compliance steps differ by country.

5) Core jobs-to-be-done

High-leverage jobs for global operations are mostly ‘decision + checklist’ work.

• Choose the right hiring model per country with clear decision criteria.
• Standardize global onboarding inputs (bank info, address, tax details as required).
• Align global pay calendars and cutoffs (avoid ‘urgent’ last-minute runs).
• Track contractor vs employee classification decisions and reviews.
• Automate global onboarding/offboarding tasks with a consistent workflow.
• Maintain compliance documentation and an audit-ready trail.

6) Happy path workflow #1

Workflow: hire a global employee using the EOR path (happy path).

1. Confirm the country and whether you have an entity there.
2. Choose EOR when you need to hire without setting up an entity.
3. Collect required worker information and employment terms early.
4. Create the worker record with complete HRIS attributes for downstream automation.
5. Kick off onboarding tasks (access, equipment, manager checklist).
6. Validate pay schedule expectations and confirm the first pay date.

7) Happy path workflow #2

Workflow: pay a global contractor reliably (without classification surprises).

1. Confirm contractor classification and required documentation for the jurisdiction.
2. Collect payout details (banking, invoice method, currency expectations).
3. Create a repeatable payment cadence and cutoff schedule.
4. Collect/approve invoices or work confirmations before payment.
5. Execute payment and record documentation for audit/finance.
6. Review contractor relationships periodically for classification risk.

8) Decision points

Global success depends on making the model decision correctly.

9) Guardrails: Do / Don’t & Common mistakes

Global guardrails = clear decisions + repeatable checklists + documentation.

10) What good looks like + Checklists

Global is ‘good’ when hiring is predictable and compliance surprises are rare.

11) Practice lab (5–15 min) + Official docs links

Practice: create a ‘global hiring decision sheet’ for one country and run a mock hire through it.

1. Pick one target country you might hire in.
2. Write the decision criteria: entity vs EOR vs contractor (simple A/B rules).
3. List the minimum onboarding fields and documents you must collect.
4. Draft a pay calendar and cutoffs for the first two pay cycles.
5. Run a mock scenario end-to-end and note where you lack information.
6. Convert notes into an updated checklist and assign owners.

1) Quick scan + Orientation

2) Mental model / Flow

Security is not one setting—it’s a set of operational routines powered by permissions, policies, identity controls, and monitoring. Good security is repeatable and reviewable, not hero-driven.

1. Define roles and least-privilege access boundaries.
2. Secure identity and access management (join/change/leave routines).
3. Protect sensitive data with scoped access and change controls.
4. Establish monitoring for exceptions and suspicious patterns.
5. Run recurring reviews (privileged access, stale accounts, integrations).
6. Document controls and evidence sources for audits.

3) Objects & Terms

Security conversations go faster when everyone uses the same words.

4) State machine / Lifecycle

Security work repeats on a cadence (weekly/monthly/quarterly).

5) Core jobs-to-be-done

These jobs create most of your security value.

• Define admin roles and remove ‘everyone is admin’ patterns.
• Secure onboarding/offboarding so access changes are automatic and timely.
• Protect sensitive data fields with restricted access and logging.
• Review privileged access regularly and remove stale access quickly.
• Audit integrations and ensure they follow system-of-record rules.
• Maintain evidence artifacts for audits and security questionnaires.

6) Happy path workflow #1

Workflow: quarterly access review (simple, high impact).

1. List your privileged roles (admins, finance control roles, IT superusers).
2. Export a current roster of who holds each privileged role.
3. Have role owners confirm each person still needs access (approve/remove).
4. Remove access for leavers, role-changers, and inactive users promptly.
5. Record decisions and reasons (audit-friendly notes).
6. Schedule the next review and track completion.

7) Happy path workflow #2

Workflow: security incident hygiene for access changes (contain fast).

1. Identify the scope: which user(s), which roles, which integrations/apps are involved.
2. Immediately revoke or suspend access for impacted accounts (containment).
3. Check recent access-change activity and integration sync events.
4. Reset credentials/keys and re-auth integrations if needed.
5. Restore access using least-privilege and confirm normal operations.
6. Run a post-incident review and update controls to prevent recurrence.

8) Decision points

Security is full of tradeoffs; make them explicit.

9) Guardrails: Do / Don’t & Common mistakes

Most security failures are process failures—guardrail the process.

10) What good looks like + Checklists

Security is ‘good’ when controls are repeatable and evidence is easy to produce.

11) Practice lab (5–15 min) + Official docs links

Practice: build a tiny ‘audit packet’ for access governance (10 minutes).

1. List your top 5 privileged roles/groups and their owners.
2. Capture a roster of who currently has each role.
3. Write the review question: “Does this person still need this access?”
4. Record one example decision (keep/remove) with a reason.
5. Create a simple cadence note (quarterly) and where evidence will be stored.
6. Share the packet with a stakeholder and get sign-off on the process.