Bamboo HR

3) Lifecycle / states in mobile

Mobile is strongest at state visibility. You should be able to see whether a request is pending or finalized and take the next action quickly.

• Time off request: Submitted → Pending → Approved/Denied.
• Approvals: Notification → Open item → Approve/deny → Confirmation.
• Payroll views: View pay info (read-only) depending on setup.
• Sync: Some changes appear after refresh/login.

5) Happy path workflow #1: Request time off in mobile

This flow is for employees who want to submit PTO/sick time quickly. The goal is a submitted request with a visible status.

1. Open the BambooHR app and select your company/account.
2. Go to Time Off.
3. Tap Request Time Off.
4. Select type, date range, and hours/days as needed.
5. Add a short note (coverage or context) if your process expects it.
6. Submit and confirm the request appears in your list/history.

6) Happy path workflow #2: Approve time off in mobile

This is for managers/approvers. The goal is to process requests quickly and leave a clear audit trail.

1. Tap the notification or open the Approvals area (if available).
2. Open the request details and review dates/type/balance impact.
3. Check for conflicts with team coverage (as your org requires).
4. Approve or deny.
5. Add a short comment if your org expects one for denials or special cases.
6. Verify the status updates to Approved/Denied.

8) Common mistakes

Mobile mistakes are often about speed—submitting the wrong thing quickly. Add a few friction checks to avoid rework.

• Wrong account/company selected: confirm company domain/account name before submitting.
• Incorrect time off dates: re-check date range before tapping submit.
• Skipping notes when required: add short context for unusual requests.
• Assuming mobile has all admin options: use web for settings/configuration.
• Ignoring denied reasons: open details to read comments before resubmitting.

9) Guardrails: Do/Don’t + integrations

Mobile works best when you treat it as a fast front door. For complex tasks, switch to web and keep decisions traceable.

3) Lifecycle / states

Requests move through clear statuses. Understanding them prevents duplicate submissions and helps you follow up at the right time.

• Created: request drafted or started.
• Submitted: request sent into approval routing.
• Pending: waiting for approver action.
• Approved/Denied: final decision recorded (often with optional comments).
• Updated/Canceled: requests can be modified or canceled depending on permissions and timing.

5) Happy path workflow #1: Employee requests time off

This is the standard employee flow. The objective is a correctly typed request with a clear status and accurate balance impact.

1. Open Time Off and select Request Time Off.
2. Choose the correct time off type (per policy).
3. Select dates and the requested amount (days/hours).
4. Add a note if your company expects coverage context.
5. Submit the request.
6. Check the request status (Pending).
7. After approval/denial, open the request to confirm details.
8. Verify balance and history reflect the outcome.

6) Happy path workflow #2: Manager approves time off

This is for approvers. The objective is fast, consistent approvals with an audit trail that employees can understand.

1. Open Approvals/Time Off requests list.
2. Review dates, type, and any employee notes.
3. Check team coverage (calendar/Who’s Out view if available).
4. Approve or deny the request.
5. Add a short comment for denials or exceptions.
6. Confirm status updates and employee notification occurs (per settings).

8) Common mistakes

Time off errors usually show up as wrong balances, wrong types, or confusion about status. Prevent them with consistent checks.

• Wrong type chosen: confirm PTO vs sick vs special leave before submitting.
• Not checking approval status: don’t assume submitted means approved.
• Editing too late: update/cancel early to avoid admin corrections.
• Misreading balances: clarify whether balances are current vs future/accrued.
• Duplicate requests: if unsure, check history before submitting again.

9) Guardrails: Do/Don’t + roles

Roles and policies define what you can do. Good guardrails keep the system clean for both employees and payroll/reporting downstream.

3) Lifecycle / states

Approvals are fundamentally state machines. Understanding the states helps you troubleshoot when something gets stuck.

• Submitted: item enters routing.
• Pending: waiting for approver action.
• Approved: accepted; downstream effects may apply (balances updated, visibility granted, etc.).
• Denied: rejected; requester may need to resubmit or correct details.
• Reassigned/Escalated: not applicable for this tool/tab unless configured in your organization’s workflow.

5) Happy path workflow #1: Approver processes a time off request

This is the most common approvals workflow. The objective is a fast decision with minimal confusion for the employee.

1. Open the approvals list/queue.
2. Select a pending time off request.
3. Review dates, type, notes, and potential coverage impact.
4. Approve or deny.
5. Add a brief comment if denying or requesting changes.
6. Confirm the request status changes immediately.
7. Optionally, communicate coverage expectations outside the system if your org requires.

6) Happy path workflow #2: Admin fixes a stuck approval (routing issue)

Sometimes requests remain pending because routing is misconfigured or roles changed. The objective is to restore a working approval path and resolve the backlog.

1. Identify the stuck request (who submitted, what type).
2. Confirm who should be the approver (manager/role policy).
3. Check whether the approver has permission to approve this item type.
4. Validate the requester’s reporting structure (manager assignment) if applicable.
5. Adjust routing/approver assignment per your org’s documented process.
6. Ask the requester to resubmit if the system cannot re-route an existing item.
7. Verify new submissions land in the correct approver queue.

8) Common mistakes

Bad approvals are usually slow, inconsistent, or unclear. Fix those and the system feels reliable.

• Approving without reviewing details: leads to coverage and balance issues.
• Denials without comments: employees don’t know how to fix and resubmit.
• Inconsistent standards across managers: document simple rules for edge cases.
• Letting requests sit pending: creates last-minute chaos; set a response SLA.
• Assuming it’s a bug: most issues are permissions/routing configuration.

9) Guardrails: Do/Don’t + roles + integrations

Approvals must be fair, fast, and explainable. Treat the system as an auditable record.

3) Lifecycle / states

Hiring is a state machine: every candidate must have a current stage and a next action. Onboarding is a checklist: tasks completed until the employee record is ready.

• Candidate: New → Screening → Interviewing → Offer → Hired/Not selected.
• Opening: Draft → Open → Filled/Closed.
• Onboarding: Packet sent → Info submitted → HR review → Employee record complete.
• Offboarding: Initiated → Tasks completed → Access removed (process varies) → Record maintained.

5) Happy path workflow #1: Manage a candidate through the pipeline

This workflow keeps candidate status accurate and visible to the team. The objective is a single source of truth for where each candidate stands.

1. Open the job opening and review the candidate list.
2. Add a candidate (or review new applicants) and confirm contact details.
3. Move candidate to the appropriate stage (e.g., screening).
4. Log communication notes or attach relevant documents (resume, feedback) as allowed.
5. Schedule/record interview progress using your team’s process.
6. Advance stage after each decision checkpoint.
7. Mark final outcome: offer/hired or not selected, with a short rationale note if needed.

6) Happy path workflow #2: Send new hire packet and complete onboarding basics

This is for HR/admins coordinating new hire self-onboarding. The objective is to collect accurate info before the first day and reduce manual data entry.

1. Confirm candidate is marked as hired (or ready for onboarding).
2. Initiate the new hire packet/self-onboarding process (as configured).
3. Send the packet to the new hire with clear deadlines.
4. Monitor completion status and follow up on missing items.
5. Review submitted information for accuracy (names, addresses, job details).
6. Finalize the employee record creation/activation.
7. Notify manager that onboarding basics are complete (start date, first-day info).

8) Common mistakes

ATS data becomes useless when stages, ownership, and notes are inconsistent. Avoid these to keep reporting and collaboration reliable.

• Skipping stage updates: pipeline becomes stale; enforce updates after every decision.
• No ownership: assign a responsible recruiter/manager for each opening.
• Too many custom stages: makes reporting messy; keep stages minimal and meaningful.
• Unstructured notes: use brief, factual notes with dates.
• Not closing openings: reporting stays inflated and confusing.

9) Guardrails: Do/Don’t + roles + integrations

Hiring workflows touch sensitive candidate data. Use role-based access and keep processes consistent across teams.

3) Lifecycle / states

A payroll run typically moves through a predictable sequence. Knowing the phase helps you prioritize what to fix and when.

• Pre-processing: collect time, updates, deductions.
• Review: validate totals, exceptions, missing info.
• Submit/process: finalize run by the deadline.
• Post-processing: pay stubs available; taxes/filings handled per service.
• Corrections: off-cycle run or adjustments if needed.

5) Happy path workflow #1: Run a standard payroll cycle

This is for payroll admins. The objective is an on-time payroll submission with correct inputs and minimal exceptions.

1. Confirm payroll calendar and processing deadline for the period.
2. Review employee changes since last run (new hires, terminations, pay changes).
3. Verify time inputs (time tracking/hours) if applicable in your setup.
4. Review deductions/withholdings changes (as available in BambooHR Payroll).
5. Run payroll preview/review step and scan for exceptions.
6. Resolve exceptions (missing info, unusual totals) before submission.
7. Submit/process payroll by the deadline.
8. Verify pay stubs/results are available per your process.

6) Happy path workflow #2: Run an off-cycle payroll

Off-cycle runs handle corrections or one-time payments. The objective is a clean supplemental payroll without disrupting the regular cycle.

1. Identify the reason and scope (who needs off-cycle pay and why).
2. Confirm whether the payment impacts taxes/withholding (per your payroll policy).
3. Create the off-cycle payroll run in BambooHR Payroll.
4. Enter or verify amounts/hours for impacted employees.
5. Review totals and validate against approval records.
6. Process the off-cycle payroll.
7. Confirm impacted employees can view the pay record as expected.

8) Common mistakes

Payroll problems usually come from rushing near deadlines or missing upstream changes. Use structured reviews to reduce risk.

• Ignoring cutoffs: set reminders and start review early.
• Not reconciling employee changes: new hires/terms can change totals significantly.
• Processing before time approvals: ensure inputs are finalized.
• Skipping exception review: unusual totals often signal missing info.
• Poor communication: employees need clear guidance on pay stub/W-2 access.

9) Guardrails: Do/Don’t + roles + integrations

Payroll is sensitive. Keep access tight, changes auditable, and processes consistent across cycles.

3) Lifecycle / states

Reporting is iterative: build once, validate, then reuse. Mature reporting systems rely on stable definitions and recurring cadence.

• Draft: initial report layout and field selection.
• Validated: numbers checked against known totals or source screens.
• Operational: reused on a schedule; saved/favorited.
• Deprecated: replaced when definitions or fields change.

5) Happy path workflow #1: Build a repeatable headcount report

The objective is a report you can reuse monthly without rework, showing current headcount by department/location (as your org tracks it).

1. Go to Reporting and choose an employee information report category.
2. Select a standard headcount-type report (or create a simple custom report if available).
3. Add fields: employee status, department, location, hire date (as needed).
4. Filter to Active employees (or your org’s definition of headcount).
5. Sort/group by department and validate totals.
6. Save the report and add it to Favorites.
7. Run it again next month using the same filters and compare changes.

6) Happy path workflow #2: Answer a time off usage question

This workflow helps you respond quickly to questions like “How much PTO was used last quarter?” The objective is a filtered time off report you can defend.

1. Open Reporting and select Time Off Reports.
2. Choose a report that lists requests/usage (depending on what your org tracks).
3. Set date range (e.g., last quarter).
4. Filter by time off type (PTO only) if needed.
5. Filter by employee status/department if relevant.
6. Validate results by sampling a few employees’ time off histories.
7. Export/share according to your organization’s data-sharing policy.

8) Common mistakes

Avoid these and your reports become trusted quickly.

• Not documenting filters: results can’t be reproduced later.
• Mixing statuses: active vs inactive employees changes totals dramatically.
• Using wrong date fields: hire date vs effective date vs request date.
• Over-sharing sensitive fields: violates internal access expectations.
• Not validating: always spot-check against known records.

9) Guardrails: Do/Don’t + permissions

Reporting is a permissions-heavy area. Keep reports scoped and definitions stable to avoid confusion and risk.

3) Lifecycle / states

Integration work is a lifecycle: evaluate → configure → test → launch → monitor. Most failures come from skipping testing or unclear ownership.

• Evaluated: integration selected and requirements defined.
• Configured: credentials, mappings, and rules set.
• Tested: pilot data and edge cases validated.
• Live: real data flows; monitoring in place.
• Maintained: updated when fields, roles, or partner APIs change.

5) Happy path workflow #1: Evaluate and select an integration

This workflow prevents tool sprawl and broken syncs. The objective is a clear business case and a vetted integration choice.

1. Write the workflow goal (e.g., ‘ATS → BambooHR employee record’).
2. List the fields that must sync (name, start date, department, etc.).
3. Decide the source of truth for each field.
4. Review partner options in the BambooHR marketplace/category page.
5. Check any plan or module requirements (e.g., hiring, payroll).
6. Confirm security needs (access scope, admin roles, audit expectations).
7. Select one integration and define a pilot group.

6) Happy path workflow #2: Configure and validate a pilot sync

This flow is for admins/IT. The objective is a verified sync that doesn’t overwrite important data unexpectedly.

1. Set up integration credentials/connection per partner instructions.
2. Map fields and define sync direction (one-way vs two-way).
3. Limit scope to a pilot group (small set of users/records).
4. Run the first sync and capture before/after snapshots.
5. Validate critical fields in BambooHR and the partner tool.
6. Test an edge case (name change, department change, termination) if your integration supports it.
7. Document results and adjust mappings/rules as needed.
8. Expand rollout only after validation.

8) Common mistakes

Integration issues can silently corrupt data. These pitfalls are the most common root causes.

• No source-of-truth decision: leads to field ping-pong and overwrites.
• Skipping pilot testing: mistakes hit the full employee base immediately.
• Over-mapping fields: sync only what you need; reduce risk surface.
• No monitoring: errors go unnoticed until payroll/reporting breaks.
• Unclear ownership: nobody is responsible for fixes when things drift.

9) Guardrails: Do/Don’t + roles

Treat integrations like production systems. Keep roles tight and changes controlled.

3) Lifecycle / states

Dashboards mature over time. Start simple, validate, then standardize for leadership cadence.

• Exploratory: you browse metrics to learn what’s available.
• Validated: you confirm metric meaning matches your org’s definition.
• Operational: dashboards are referenced on a schedule with stable interpretations.
• Refreshed: definitions adjusted only when org policy changes (document updates).

5) Happy path workflow #1: Prepare a leadership dashboard snapshot

The objective is a 5-minute dashboard review you can share confidently because definitions are clear and validated.

1. Open Dashboards & Analytics and select the relevant dashboard view.
2. Identify 3–5 KPIs leaders care about (headcount, hiring pipeline, time off).
3. Check the date range/filters implicitly applied (if visible).
4. Validate one KPI using a corresponding report (spot-check).
5. Capture the key change since last review (trend, segment shift).
6. Write 1–2 bullets explaining what changed and why it might matter.

6) Happy path workflow #2: Investigate a dashboard anomaly with reports

Dashboards can surface unexpected spikes/drops. The objective is to confirm whether it’s real or a data definition/quality issue.

1. Identify the KPI that changed unexpectedly.
2. Note the segment/time period where the change is concentrated.
3. Open Reporting and find the report category that matches the KPI.
4. Apply filters to match the dashboard segment/time period.
5. Compare results; identify the top contributors (employees, departments, events).
6. Decide action: correct data, update definitions, or escalate a real trend to leadership.

8) Common mistakes

Dashboards fail when people over-trust them without understanding definitions.

• Presenting KPIs without definitions: stakeholders interpret differently.
• No validation: one report spot-check prevents embarrassment.
• Changing definitions silently: causes whiplash in trend interpretation.
• Using dashboards for audits: audits need detailed reports and history.
• Ignoring segment changes: totals can hide department-level problems.

9) Guardrails: Do/Don’t + permissions

Dashboards are a communication tool. Keep them consistent, permission-safe, and aligned with reporting truth.