Workday HCM
Workday HCM is an enterprise human capital management platform (Human Capital Management). It provides comprehensive HR management, recruitment, compensation, performance, and data analytics, suitable for large enterprises and corporations.
- Overview & Navigation Basics
- Core HCM (Worker Data, Org, Jobs)
- Recruiting & Hiring
- Talent & Performance (High-level)
- Time Off & Absence Management
- Security & Permissions
- Business Processes & Approvals (BPF)
- Reporting & Workforce Analytics (High-level)
- Integrations & APIs (REST Directory)
- Mobile & Employee Self-Service (High-level)
- Getting Started (Employee Journey View)
Overview & Navigation Basics
Quick scanRead time: ~8–12 min
Audience: new HR/manager/employee users
- Understand what Workday HCM covers across the employee journey (plan-to-hire → retire).
- Learn the 3 navigation habits that make Workday feel predictable: Search, Worklets/Apps, and Inbox tasks.
- Recognize where “business processes” and approvals show up in day-to-day actions.
- Know what you can do safely vs. when you should stop and ask HR/Security.
1) Purpose / Outcome
Workday HCM is a cloud platform for managing the employee lifecycle and HR operations in one place. Your outcome in this tab is to navigate confidently, complete basic tasks, and understand why approvals appear.
- Use global Search to find tasks (e.g., “Change Personal Information”, “Request Time Off”).
- Use your Home worklets/apps to access common areas (People/Team, Time Off, Recruiting, etc.).
- Open your Inbox daily to complete tasks and approvals (your work queue).
- Use “Related Actions” (often a button/menu near a name/object) to take contextual actions.
- Use filters on lists (date, status, organization) before exporting or reporting.
2) Who this is for + When to use
This is for anyone new to Workday HCM: employees (self-service), managers (team actions), and HR partners (transactions). Use it when you’re unsure where a task lives or why Workday is asking for approvals.
- Employees: profile updates, time off, viewing pay/benefits (if enabled).
- Managers: hiring requests, job/comp changes, approvals, team reporting.
- HR: worker lifecycle events, data governance, business process routing.
- Use before making changes that affect pay, position, or security access.
3) Where in navigation + Related tabs
Workday HCM is typically organized around worklets/apps and task search. Related learning tabs in this guide: Core HCM Recruiting & Hiring Absence Security Business Processes.
- Start from: Home → Worklets/Apps (common entry points).
- Backup: Search (best for “I know the task name”).
- Work queue: Inbox (best for approvals + follow-up tasks).
- Context menu: Related Actions (best for “I’m on a worker record already”).
4) Mental model / Flow
Most Workday actions trigger a built-in business process (BPF): an event starts a workflow, steps route to the right people, and completion updates records. If you see approvals, it’s usually the business process rules doing their job.
- Trigger: you submit a task (e.g., request time off).
- Validation: required fields & eligibility rules are checked.
- Routing: approvals/tasks go to roles (manager, HR, security).
- Completion: records update; audit trail is stored.
Expected outcome: You can predict where to look next: Inbox for tasks, or the record’s “Process History”/status view (if enabled).
5) Objects & Terms
Workday uses consistent objects across modules. Learning the names helps you search and understand screens.
- Worker: employee/contingent worker record.
- Organization: supervisory orgs, cost centers, companies (tenant-specific).
- Position / Job: position-managed vs job-managed models (tenant choice).
- Business Process: the approval/task workflow engine.
- Security Group/Role: controls what you can see/do.
- Inbox: your tasks/approvals queue.
6) State machine / Lifecycle
Many actions have statuses (Draft → Submitted → In Progress → Completed/Denied). Exact labels vary by tenant configuration.
- Draft: not yet submitted; safe to cancel/edit.
- Submitted: routed into approvals; may be recalled depending on rules.
- In Progress: one or more steps pending in someone’s Inbox.
- Completed: updates applied; appears in history/audit.
- Denied/Cancelled: no changes applied (or partial, if configured).
7) Core jobs-to-be-done
These are the most common “first week” tasks for new users.
- Find a task by name using Search and run it safely.
- Complete an Inbox task and confirm the next step/owner.
- Navigate to a worker record and use Related Actions.
- Check status/history of a submitted request.
- Export a list/report responsibly (don’t overshare).
8) Happy path workflow #1: Complete an Inbox approval
Use this when you receive an approval (hire, time off, change request). Goal: approve/deny with confidence and leave a clear audit trail.
- Open Inbox from Home.
- Select the top-priority item (check due date/urgency).
- Read the summary and open details (attachments/comments).
- Validate required info (dates, worker, org, compensation if relevant).
- If unclear, add a comment or send back per tenant flow.
- Click Approve or Deny (include reason when denying).
- Confirm the item disappears or shows as completed.
Expected outcome: The business process advances to the next step/role, with your decision recorded.
9) Happy path workflow #2: Find and run a common task
Use this when you know what you want to do but don’t know where it lives. Goal: locate the correct task and submit without errors.
- Use global Search and type the task name (start broad).
- Pick the result that’s labeled as a Task (not a report/object).
- Read the task description (if present) and required fields.
- Fill required fields first; then optional fields.
- Review for sensitive data (especially manager/HR tasks).
- Submit and note any confirmation/status message.
- Check Inbox or status/history for next steps.
Expected outcome: Your request is submitted into the correct business process and routed for approvals if required.
10) Decision points
Use this table to decide what to do next when Workday behavior surprises you.
| Situation | If A… | If B… |
|---|---|---|
| Search results show multiple similar tasks | Choose the one labeled Task + matches your role scope. | Open each in new tabs; compare required fields; ask HR if unsure. |
| You can’t see a button/action | Likely security: confirm you have the right role assignment. | Or you’re on the wrong object page; use Related Actions on the correct record. |
| Your request is “stuck” | Check who owns the next Inbox step (if visible) and nudge them. | If not visible, ask HR/Support for process status. |
| You need to change something sensitive (pay/org/security) | If you’re authorized, follow the official transaction task. | If not authorized, stop and contact HR/Security. |
11) Common mistakes (and how to avoid)
- Mistake: Approving without reading attachments. Avoid: open details and verify key fields before approving.
- Mistake: Using the wrong “similar” task. Avoid: prefer task results + match your role scope.
- Mistake: Assuming no approval is needed. Avoid: expect routing via business processes for many changes.
- Mistake: Exporting data widely. Avoid: follow least-privilege and share only what’s needed.
- Mistake: Editing from the wrong record. Avoid: use Related Actions from the correct worker/position/org object.
12) Permissions & Roles
Workday uses role-based access; what you see depends on security roles and org assignments. (Tenant-specific details vary.)
13) Data & Integrations
If your tenant exposes APIs or integrations, they typically follow Workday services (REST/SOAP) and enforce the same security model.
14) What good looks like
- You can find tasks via Search and complete them without trial-and-error.
- You can explain why an approval appeared (business process routing).
- You can check status/history and know the next owner/step.
- You don’t export or share sensitive HR data unnecessarily.
15) Checklist: Pre-check + Post-check
Pre-check
- I’m on the correct worker/org record.
- I know which task (not report) I should run.
- I have required info (dates, org, reason codes if used).
- I understand who will approve next.
- I’m not changing pay/security unless authorized.
Post-check
- I got a confirmation/status message.
- I added comments/attachments when needed.
- I checked Inbox for follow-up tasks.
- I verified the record updated (or is pending approval).
- I can tell who owns the next step.
16) Practice lab (5–15 min)
Goal: build navigation muscle memory without making risky changes.
- Use Search to find a harmless “View” report/task available to you.
- Open your own worker profile and locate basic fields (contact, org, manager).
- Open Inbox and review a completed item (if available).
- Use Related Actions on yourself to see what actions are permitted.
- Find the help/support link your tenant provides (if present).
Verify you did it right: You can repeat steps 1–4 quickly and can explain what’s controlled by security vs navigation.
17) Official docs links
- Workday HCM product overview & core areas (Core HCM, Talent, Workforce Management, etc.).
- Workday business process framework (how approvals/workflows are built-in).
- Workday REST API directory (example of official service catalog).
Core HCM (Worker Data, Org, Jobs)
Quick scanRead time: ~10–14 min
Focus: the “system of record” basics
- Understand what Core HCM typically means: worker records, organizations, job/position data, lifecycle changes.
- Learn safe vs risky edits (self-service vs HR transactions).
- Practice checking status/history and confirming data consistency.
- Map where approvals come from (business process routing).
1) Purpose / Outcome
Core HCM is where foundational worker and organization data lives. The outcome is to make correct updates (or request changes) and avoid breaking downstream processes like recruiting, absence, or reporting.
- Know what data is “owned” by employee vs manager vs HR.
- Use the correct transaction task for changes (not manual workarounds).
- Validate required fields and effective dates before submitting.
- Understand how changes route through business processes.
2) Who this is for + When to use
Employees use Core HCM for profile and personal data (if enabled). Managers and HR use it for job/organization changes and worker lifecycle events.
- Employee: review/update contact info and personal details (tenant-specific).
- Manager: initiate team changes, view org/team data.
- HR: process worker lifecycle transactions and data governance.
- Use this tab before changing anything that affects eligibility, org alignment, or reporting.
3) Where in navigation + Related tabs
Typical entry points: Search → worker tasks; Home → People/Team worklet; Worker profile → Related Actions. Related tabs: Recruiting & Hiring Security Business Processes Reporting.
- Search for tasks by intent: “Change”, “Request”, “View”.
- Open the worker record first when you need contextual actions.
- Use Inbox for follow-ups (documents, approvals, confirmations).
- Check process/status views when something looks delayed.
4) Mental model / Flow
Core HCM changes are usually effective-dated and controlled by business processes. You submit a transaction, Workday routes approvals/tasks, and then updates the worker/org records.
- Identify the correct object (worker, org, position/job).
- Run the correct change task and set effective date.
- Provide reason codes/comments as required by your tenant.
- Submit → approvals/tasks route → completion updates records.
Expected outcome: The record updates on the intended effective date, and downstream areas (absence, recruiting, reporting) stay consistent.
5) Objects & Terms
Core HCM is built on consistent objects that appear everywhere.
- Worker: central person record (employee/contingent).
- Supervisory Organization: manager-led org structure (common in Workday).
- Company / Cost Center: financial/administrative org elements (tenant-defined).
- Job Profile: standardized role definition (skills/requirements).
- Position: a slot in the org (position management) or Job (job management).
- Effective Date: when a change becomes active.
6) State machine / Lifecycle
Worker lifecycle varies by tenant but commonly includes lifecycle events with statuses managed by business processes.
- Pre-hire/Candidate → Hire → Active.
- Change events (job/comp/org) → pending approvals → completed.
- Leave/absence states may interact with worker status.
- Termination/retire → inactive; history retained.
- Note: Exact labels depend on configuration.
7) Core jobs-to-be-done
These are the practical “core” jobs most tenants support.
- View a worker profile and key org assignments.
- Request/update personal information (if enabled for employees).
- Initiate a job/organization change (manager/HR).
- Attach supporting documents to a transaction.
- Track a submitted change through approvals to completion.
8) Happy path workflow #1: Update personal/contact info (employee)
Use this when you need to update your own information that your tenant allows for self-service.
- Search for the relevant task (e.g., “Change Contact Information”).
- Confirm you’re editing your own profile (not someone else’s).
- Enter updated fields; keep formatting consistent (phone, address).
- Attach documents if your tenant requires proof (rare; tenant-specific).
- Submit and read confirmation.
- Check Inbox for follow-up tasks (if any).
- Verify the updated info appears on your profile.
Expected outcome: Your info updates (immediately or after approvals), and the change is logged.
9) Happy path workflow #2: Initiate a team change (manager)
Use this when you need a standard team change (org move, job change) as a manager, if your role is permitted.
- Open the worker record (your team member).
- Use Related Actions → choose the appropriate “Change Job/Move Worker” type task (tenant-specific naming).
- Set the effective date and reason.
- Fill required org/position/job fields carefully.
- Review impacts (comp, location, costing) if shown.
- Submit and confirm routing/approvals.
- Monitor Inbox for any follow-up tasks you own.
Expected outcome: The change routes through approvals and updates the worker record on the effective date.
10) Decision points
| Situation | If A… | If B… |
|---|---|---|
| Position vs Job model | If your tenant is position-managed, pick the correct position and verify availability. | If job-managed, ensure the job profile + org assignments are correct. |
| Effective date confusion | If change is future-dated, confirm downstream systems know the timing. | If immediate, ensure approvals can complete in time (or adjust effective date). |
| Missing required fields | Search for help text or task guidance in the UI; fill required first. | If you don’t have the data, stop and request it from HR/admin. |
| Security blocks the action | If it’s expected, escalate to HR/security role owner. | If unexpected, verify you’re on the correct worker/org and correct task. |
11) Common mistakes (and how to avoid)
- Mistake: Ignoring effective dates. Avoid: always confirm when the change should take effect.
- Mistake: Choosing the wrong org. Avoid: cross-check supervisory org and manager chain.
- Mistake: Submitting without reason/comments. Avoid: use required reason codes for audit/reporting.
- Mistake: Treating Workday like a spreadsheet. Avoid: use transactions + approvals (BPF), not manual edits.
- Mistake: Sharing exported worker data widely. Avoid: follow least-privilege and policy.
12) Permissions & Roles
Core HCM actions are heavily role-controlled; managers/HR may see different tasks on the same worker record.
13) Data & Integrations
Core worker/org data often feeds reporting and integrations; use official APIs/services if your tenant exposes them.
14) What good looks like
- Changes are submitted through the correct task and routed properly.
- Effective dates and reasons are consistent and auditable.
- Records remain consistent across related modules (absence, recruiting, analytics).
- Security/access boundaries are respected.
15) Checklist: Pre-check + Post-check
Pre-check
- I know which object I’m changing (worker/org/position).
- I have the correct effective date + reason.
- I verified I’m authorized to do this action.
- I collected required fields/documents.
- I understand likely approvals/owners.
Post-check
- I received confirmation and/or process status.
- I completed any follow-up tasks in Inbox.
- I verified the worker record reflects the intended change.
- I documented comments for audit clarity.
- I notified stakeholders (if policy requires).
16) Practice lab (5–15 min)
Goal: learn the worker record layout and safe actions.
- Open your own worker record and locate org/manager and contact info.
- Use Related Actions and list which actions are allowed vs not visible.
- Find a “View” report for your org/team and apply a filter.
- Export (if allowed) and immediately store/delete per policy (practice safe handling).
Verify you did it right: You can explain what changed (or didn’t) and why (security + business process).
17) Official docs links
- Workday HCM overview (core areas across HCM).
- Workday business process framework (how transactions route).
Recruiting & Hiring
Quick scanRead time: ~10–15 min
Focus: create hire → offer → hire into worker record
- Understand the typical hiring flow: plan/requisition → candidate → offer → hire.
- Learn what managers vs HR usually do in Workday recruiting steps.
- Practice safe validation before approvals (org, comp, documents).
- Know how the business process framework drives approvals and tasks.
1) Purpose / Outcome
Recruiting & Hiring covers the process of bringing a new worker into the organization—from opening a role to converting a candidate into a worker record. Your outcome is to execute the hire steps cleanly, with correct approvals and documentation.
- Initiate or review the hire request with correct role details.
- Track candidates through stages (tenant-specific stages).
- Prepare/review an offer and capture acceptance.
- Hire the accepted candidate into a job/position with correct data.
2) Who this is for + When to use
Managers typically initiate hiring needs and approvals; HR often manages offers and compliance steps. Use this tab when you need to move a candidate to hire without breaking approvals or data quality.
- Hiring Manager: requisition approvals, interview feedback, final approvals.
- Recruiter/HR: offer creation, onboarding handoff, compliance steps.
- Approvers: org leadership, budget owners (tenant-specific).
- Use before approving offers/hire to validate comp and start date.
3) Where in navigation + Related tabs
Common entry points: Recruiting/Hiring worklet/app, Search for “Hire” tasks, Inbox approvals. Related tabs: Core HCM Business Processes Security.
- Use recruiting pipelines/candidate lists (if enabled).
- Open the requisition/candidate record, then use Related Actions.
- Use Inbox to approve offers/hire steps.
- Check process status/history if handoffs stall.
4) Mental model / Flow
Hiring typically starts as a request and ends as a worker record—driven by business processes. A candidate becomes a pre-hire (often) and then is hired into a position/job with effective dates.
- Create/approve requisition or hiring request (tenant-specific).
- Move candidate through stages; capture interview feedback.
- Prepare offer → review → send for e-sign/acceptance.
- Hire the worker into a position/job; trigger onboarding tasks.
Expected outcome: The candidate is hired, worker record is created/updated, and downstream onboarding tasks are launched.
5) Objects & Terms
- Job Requisition: approved request to hire.
- Candidate: applicant record in pipeline.
- Pre-hire: pre-employee record used before hire (common concept).
- Offer: compensation and terms requiring review/approval.
- Hire: transaction that creates/activates a worker.
- Business Process: approvals/tasks routing engine.
6) State machine / Lifecycle
Recruiting is stage-based. Exact stages vary by tenant, but the idea is consistent: candidate progresses until acceptance, then hire completes.
- Pipeline stages: applied → screening → interview → offer → accepted (labels vary).
- Offer states: draft → review → sent → accepted/declined.
- Hire states: initiated → approvals → completed (worker active on start date).
- If denied: candidate may revert or close out per process rules.
7) Core jobs-to-be-done
- Initiate a hire request/requisition (manager/HR depending on tenant).
- Advance candidate stages and record feedback.
- Prepare and route an offer for review and signature.
- Hire the candidate into a position/job opening.
- Confirm onboarding tasks and start date alignment.
8) Happy path workflow #1: Offer → acceptance (manager + HR)
This workflow aligns with typical org practices where HR prepares the offer and the manager reviews before sending.
- HR prepares the offer details (comp, start date, location).
- Manager reviews the offer in Workday and adds comments if needed.
- HR routes the offer for required approvals (budget/leadership).
- Offer letter is generated and sent for electronic signature (tenant-specific).
- Candidate accepts; status updates in Workday.
- HR notifies manager and transitions to hire step.
Expected outcome: Offer is accepted and the candidate is ready to be hired into a worker record.
9) Happy path workflow #2: Hire a worker into a position/job
This focuses on the “hire transaction” where the worker record becomes active with correct org and role data.
- Open the accepted candidate/pre-hire record.
- Start the “Hire” task (task name varies by tenant).
- Select position/job opening (or job profile) and supervisory org.
- Enter start date/effective date and key details (location, time type).
- Review compensation details if included in flow.
- Attach required documents (if required by your tenant).
- Submit and monitor approvals via Inbox/status.
Expected outcome: The worker is hired and becomes active on the start date, with approvals captured.
10) Decision points
| Situation | If A… | If B… |
|---|---|---|
| Background check requirement | If required, ensure the check is initiated and tracked before final hire. | If optional, document decision per policy and proceed. |
| Compensation uncertainty | If comp is finalized, lock details in offer/hire steps. | If not, pause and align with HR/comp team before sending offer. |
| Position available? | If position is open, assign candidate to it during hire. | If not, coordinate to create/open position or use job-managed flow. |
| Approvals are delayed | If you can see next owner, nudge politely with context. | If you can’t, ask HR/support to trace business process step owner. |
11) Common mistakes (and how to avoid)
- Mistake: Sending offer without final approvals. Avoid: confirm approval steps completed before sending.
- Mistake: Wrong supervisory org/manager assignment. Avoid: validate reporting chain before hire completes.
- Mistake: Start date mismatches across steps. Avoid: keep one authoritative start date and reuse it.
- Mistake: Missing attachments/policy docs. Avoid: use a checklist per role/country.
- Mistake: Hiring into wrong position/job profile. Avoid: double-check requisition/position identifiers.
12) Permissions & Roles
Hiring tasks and approvals depend on role assignments (manager, recruiter, HR partner, leadership). Tenant security controls who can initiate vs approve.
13) Data & Integrations
Hiring often integrates with background checks and e-signature tools (tenant-specific). If exposed via APIs, services are listed in official directories.
14) What good looks like
- Offer and hire data match (start date, location, comp).
- Approvals are complete and auditable.
- Candidate → worker conversion is clean with minimal rework.
- Onboarding handoff starts automatically (or is clearly triggered).
15) Checklist: Pre-check + Post-check
Pre-check
- Requisition/position is approved and open.
- Offer details are complete and reviewed.
- Approvers are identified and available.
- Start date and manager/org are confirmed.
- Compliance items (docs/checks) are known.
Post-check
- Offer shows accepted (or signed) status.
- Hire transaction is submitted and routed.
- Worker record is created/active on start date.
- Onboarding tasks are launched/assigned.
- Stakeholders are notified per process.
16) Practice lab (5–15 min)
Goal: learn the hiring flow without making real changes (use sandbox if available).
- Watch a short official/educational hiring demo to learn terminology.
- In your tenant (or training tenant), search for the “Hire” task and open it to review required fields (don’t submit).
- Open a sample candidate/pre-hire record (if training data exists) and explore Related Actions.
- List which approvals would likely be triggered in your org.
Verify you did it right: You can describe the flow from offer to hire and identify where approvals occur.
17) Official docs links
- Workday HCM employee journey framing (plan to hire → retire).
- Hiring process demos (overview of hire transaction).
- Business process framework (approval/workflow engine).
Talent & Performance (High-level)
Quick scanRead time: ~8–12 min
Note: tenant capabilities vary
- What Talent Management generally covers: goals, performance, development, succession (tenant-dependent).
- How to approach talent cycles with checklists and clear outcomes.
- How approvals and roles may apply (manager vs employee vs HR).
- What to do if your tenant doesn’t enable a sub-feature (mark as N/A).
1) Purpose / Outcome
Talent and performance features help organizations develop, evaluate, and retain people. Your outcome is to complete a talent cycle (goal setting, check-ins, reviews) with consistent data and clear documentation.
- Set/align goals (if enabled) and keep them measurable.
- Document feedback and check-ins consistently.
- Complete review tasks on time via Inbox.
- Use reports to track completion and quality.
2) Who this is for + When to use
Managers and employees use talent features during goal cycles and reviews. HR/People teams configure cycles and monitor completion.
- Employees: goals, self-evaluations, development plans (if enabled).
- Managers: check-ins, evaluations, calibration inputs (if enabled).
- HR: cycle setup, eligibility, reminders, reporting.
- Use this tab at the start of a cycle and before deadlines.
3) Where in navigation + Related tabs
Typical entry points: Talent/Performance worklet/app, Inbox tasks, and worker/team pages. Related: Core HCM Reporting & Analytics Business Processes.
- Search “Goals”, “Performance Review”, “Feedback” tasks (names vary).
- Use Inbox for review and approval tasks.
- Use team dashboards (if available) to track progress.
- Use reports to identify missing submissions.
4) Mental model / Flow
Talent cycles are time-boxed workflows: tasks are assigned to employees/managers, routed for approvals where needed, then closed for reporting.
- Cycle launches → tasks appear in Inbox.
- Employee/manager completes forms and adds comments.
- Optional approvals/calibration steps route by role.
- Cycle closes → reporting and next-cycle planning starts.
Expected outcome: Submissions are complete, auditable, and ready for analytics and decisions.
5) Objects & Terms
- Goal: measurable outcome; may roll up to team goals (if enabled).
- Review: evaluation document/task with ratings/comments (if enabled).
- Feedback: notes captured during cycle (if enabled).
- Development Plan: learning/growth plan (if enabled).
- Business Process: routing engine for tasks/approvals.
6) State machine / Lifecycle
Cycle artifacts generally move from draft to submitted to completed, with optional manager approvals or calibration steps.
- Draft: work in progress.
- Submitted: waiting on manager/next step.
- In progress: routing through approval/calibration tasks.
- Completed: closed and reportable.
- If your tenant doesn’t enable this: Not applicable for this tool/tab
7) Core jobs-to-be-done
- Create/update goals (if enabled).
- Complete self-review (if enabled) with evidence and examples.
- Complete manager review and submit on time.
- Run completion reports and chase missing items.
- Document decisions and next steps (development plan).
8) Happy path workflow #1: Employee completes self-review
Use when your cycle opens and you receive a self-evaluation task.
- Open Inbox and start the self-review task.
- Review goals/role expectations (if shown).
- Write 3–5 evidence bullets (projects, metrics, outcomes).
- Call out learning and improvement areas with actions.
- Save draft, re-check for clarity, then submit.
- Confirm submission status and next step owner.
Expected outcome: Self-review is submitted, routed to manager, and visible in reporting.
9) Happy path workflow #2: Manager completes review + submits
Use when you receive review tasks for direct reports.
- Open Inbox and select a direct report’s review.
- Read self-review and supporting notes.
- Add ratings/comments per your org’s rubric (if enabled).
- Document strengths with specific examples.
- Document development areas with a concrete plan.
- Submit and confirm next steps (calibration/acknowledgement).
Expected outcome: Reviews are submitted consistently, enabling calibration and org reporting.
10) Decision points
| Situation | If A… | If B… |
|---|---|---|
| Your tenant has ratings | Use the rubric; keep comments consistent with rating. | If no ratings, use structured narrative + measurable outcomes. |
| Calibration step exists | Hold submission until you’re ready for calibration discussion. | If none, submit early and focus on clarity and evidence. |
| Late submissions | Run completion report and nudge with due dates. | If blockers exist, escalate to HR/People Ops for deadline handling. |
| Feature not enabled | Use alternative HR process (documents/forms outside Workday). | Mark as Not applicable and do not invent steps. |
11) Common mistakes (and how to avoid)
- Mistake: Vague comments. Avoid: use evidence + outcomes + next actions.
- Mistake: Rating mismatch with narrative. Avoid: cross-check rubric and examples.
- Mistake: Saving everything for deadline day. Avoid: draft early, then refine.
- Mistake: Surprises in reviews. Avoid: document feedback throughout the cycle.
- Mistake: Using Workday if feature not enabled. Avoid: confirm tenant capabilities first.
12) Permissions & Roles
Access depends on role (employee/manager/HR) and org assignments; tasks route via business processes.
13) Data & Integrations
Not applicable for this tool/tab (public official sources in this run did not specify Talent integrations; tenant-specific).
14) What good looks like
- Submissions are complete, evidence-based, and consistent across team.
- Managers submit on time; minimal rework after calibration.
- Development actions are clear and trackable.
15) Checklist: Pre-check + Post-check
Pre-check
- I know the due date and required sections.
- I gathered evidence (projects/metrics/feedback).
- I understand the rubric (if used).
- I know who reviews/approves next.
- I confirmed feature is enabled in tenant.
Post-check
- Status shows submitted/completed.
- Comments are specific and constructive.
- Next steps are documented (development actions).
- Team completion report looks healthy.
- Audit trail is clear (no missing context).
16) Practice lab (5–15 min)
Goal: practice writing evidence-based feedback quickly.
- Draft 3 measurable goals for your role (even offline).
- Write 1 self-review paragraph per goal: outcome + evidence + learning.
- Write 1 manager-style feedback note: strength + suggestion + action.
- If your tenant has a talent task, open it and map fields to your draft (don’t submit).
Verify you did it right: Another person can read your notes and understand outcomes and next steps without extra context.
17) Official docs links
- Workday HCM overview includes Talent Management as a core area.
- Business process framework (how tasks/approvals are routed).
Time Off & Absence Management
Quick scanRead time: ~9–13 min
Focus: request → approval → balance tracking
- Learn what Absence Management supports: time off/leave requests, balances, accruals, approvals.
- Practice the employee request flow and manager approval flow.
- Understand policy-driven rules (eligibility, overlap checks) are tenant-specific.
- Know where to check balances and request status.
1) Purpose / Outcome
Workday Absence Management helps manage time off and leaves with approvals, tracking, and reporting. Your outcome is to submit correct requests, approve responsibly, and keep balances accurate.
- Employees request time off/leave in a consistent, policy-compliant way.
- Managers approve/deny with context and staffing awareness.
- Teams can see balances and avoid scheduling conflicts.
- Approvals and audit history remain clear.
2) Who this is for + When to use
Employees use it to request time off and view balances. Managers use it to approve requests and manage coverage. HR/People teams configure policies and monitor compliance.
- Employee: request time off, view balances/accruals.
- Manager: approve requests, monitor overlap, review dashboards (if enabled).
- HR: define policies/leave plans (tenant setup).
- Use this tab before peak holiday periods to reduce conflicts.
3) Where in navigation + Related tabs
Common entry points: Absence/Time Off worklet/app, Search “Request Time Off”, Inbox approvals. Related: Business Processes Reporting Security.
- Employees: Home → Time Off/Absence.
- Managers: Inbox approvals + team dashboards (if available).
- Use calendars (if integrated) to check overlap when approving.
- Use reports to identify patterns and compliance risks.
4) Mental model / Flow
Absence actions are policy-driven workflows. You request time off, Workday validates eligibility and balances, routes approval, and then updates balances and calendars.
- Employee requests time off/leave with dates and type.
- System validates rules (balances, eligibility, overlaps).
- Approval routes to manager/role per policy.
- Completion updates balances and visibility for planning.
Expected outcome: Request status is clear (approved/denied/pending), and balances reflect the result.
5) Objects & Terms
- Time Off: short absences (vacation, sick) depending on policy.
- Leave of Absence: longer or regulated leave types.
- Balance: available time off based on accrual/policy.
- Accrual: earning rules for time off.
- Approval: routed via business process steps.
6) State machine / Lifecycle
- Draft → Submitted → Pending approval → Approved/Denied.
- Approved requests may be cancellable per policy.
- Leave cases may have additional documentation steps (tenant-specific).
- Statuses and terminology can vary by tenant configuration.
7) Core jobs-to-be-done
- Request time off with correct type and dates.
- Check balance and avoid overdrawing.
- Manager reviews overlap and approves/denies.
- Cancel or correct a request when plans change.
- Report on time off trends for planning (if enabled).
8) Happy path workflow #1: Employee requests time off
Use this when you need to request time off or a leave type your tenant supports.
- Open Absence/Time Off area or search “Request Time Off”.
- Select the correct time off type (vacation/sick/etc.).
- Enter start/end dates and partial-day details if needed.
- Review the balance impact shown (if displayed).
- Add notes for manager context (optional but helpful).
- Submit and confirm status message.
- Check request status and your updated balance view.
Expected outcome: Request routes to approver and, once approved, balance and visibility update.
9) Happy path workflow #2: Manager approves time off
Use this when you receive an absence approval in Inbox.
- Open Inbox and select the time off request.
- Review dates, type, and employee notes.
- Check team coverage/overlap (calendar/dashboard if available).
- Confirm policy compliance (balance/eligibility cues).
- Approve or deny; include reason if denying.
- Confirm completion and notify employee if needed.
Expected outcome: Request updates to approved/denied, and records reflect decision with audit trail.
10) Decision points
| Situation | If A… | If B… |
|---|---|---|
| Insufficient balance | If policy allows negative/advance, proceed with guidance. | If not allowed, adjust dates/type or deny with reason. |
| Overlapping absences | If coverage is fine, approve and note expectations. | If coverage is risky, negotiate alternate dates before approving. |
| Leave needs documentation | If required, request/upload docs and follow policy steps. | If not required, proceed with normal approval. |
| Need to change request after approval | If policy allows, cancel/modify and resubmit. | If policy restricts, contact HR/admin for correction process. |
11) Common mistakes (and how to avoid)
- Mistake: Picking the wrong absence type. Avoid: confirm type definitions in your policy list.
- Mistake: Forgetting partial-day settings. Avoid: review hours/half-day options if applicable.
- Mistake: Approving without checking overlap. Avoid: quickly check team calendar or dashboard.
- Mistake: Not documenting exceptions. Avoid: add comments for audit clarity.
- Mistake: Assuming balances update instantly. Avoid: re-check after approval completion.
12) Permissions & Roles
Approvals and visibility depend on security roles (employee vs manager vs HR) and org assignment.
13) Data & Integrations
Workday provides an Absence Management service for accessing worker leave/time-off details and requesting time off (API availability depends on tenant).
- Use official services/APIs where your org supports integrations.
- Ensure security and data sharing rules are followed.
- Validate that API actions match UI policies and approvals.
- Log and monitor requests for audit and troubleshooting.
14) What good looks like
- Requests are accurate (type/dates) and approved with context.
- Balances and calendars remain consistent.
- Managers manage coverage proactively using visibility tools.
- Audit trail includes reasons for exceptions/denials.
15) Checklist: Pre-check + Post-check
Pre-check
- I selected the correct absence type.
- I confirmed dates/partial days.
- I checked balance impact (if shown).
- I considered overlap/coverage implications.
- I added notes if needed for approver clarity.
Post-check
- Status is approved/denied/pending as expected.
- Balance reflects the request outcome.
- Manager/employee can see the request in history.
- Calendar/visibility updates (if enabled).
- Any follow-up tasks were completed.
16) Practice lab (5–15 min)
Goal: get comfortable with request and status tracking.
- Open your balance view and note current available time off.
- Start a time off request and fill fields up to review stage (don’t submit if you shouldn’t).
- Locate where request history/status appears in your tenant.
- As a manager (if applicable), open an approval item and review coverage cues.
Verify you did it right: You can find balances, submit (or simulate) a request, and locate status/history quickly.
17) Official docs links
- Workday Absence Management product capabilities (key functions and experience).
- Workday REST API directory (Absence Management service listing).
Security & Permissions
Quick scanRead time: ~10–14 min
Focus: roles → access → safe troubleshooting
- Understand role-based access: what you see/do depends on security roles and org assignment.
- Learn the two common security control areas: domain access (data) and business process access (actions/approvals).
- Practice a safe troubleshooting flow when a button/action is missing.
- Know how security impacts integrations and API access.
1) Purpose / Outcome
Security ensures people only see and do what they’re allowed to in Workday. Your outcome is to understand why access differs by user, request access correctly, and avoid risky workarounds.
- Recognize security roles and their scope (org-based assignments).
- Diagnose “missing button” issues without guessing.
- Request changes through proper channels (HRIS/security admin).
- Maintain least privilege for sensitive HR data.
2) Who this is for + When to use
This is for HRIS/security admins, HR partners, and managers who handle approvals or sensitive data. Use it when access seems wrong or when onboarding new roles/users.
- HRIS/Security: configure roles/groups and policies.
- HR/Managers: understand approval routing and access limits.
- Employees: understand why you can’t see certain data/actions.
- Use after role changes, org moves, or new process launches.
3) Where in navigation + Related tabs
Security configuration is typically admin-only via security tasks. Related tabs: Business Processes Integrations & APIs Core HCM.
- Admins use tasks like creating/configuring security groups (tenant-specific task names).
- Users experience security via what they can see on records and what tasks appear.
- Approvals depend on business process roles and assignments.
- API access follows the same security model.
4) Mental model / Flow
Security is “who + scope + permission.” Roles/groups grant permissions, scope is often defined by organizations, and policies apply to domains (data) and business processes (actions/approvals).
- Assign user to a security group/role.
- Define scope (which orgs/workers/data applies).
- Grant domain access (view/modify data).
- Grant business process policy access (initiate/approve steps).
Expected outcome: Users see the right data/actions, and approvals route to correct roles without oversharing.
5) Objects & Terms
- Security Role: role assigned to users to act/approve/support orgs.
- Security Group: grouping construct used for permissions (tenant-specific).
- Domain Security: data access control (view/modify).
- Business Process Policy: who can initiate/approve each step.
- Least Privilege: only grant what’s necessary.
6) State machine / Lifecycle
Security changes typically follow: request → approval → assignment → effective (sometimes with timing/effective dates). Exact lifecycle is tenant-specific.
- Requested: user needs access due to role change.
- Approved: security owner confirms justification.
- Assigned: roles/groups applied with scope.
- Validated: user tests access; issues are corrected.
7) Core jobs-to-be-done
- Explain why two users see different actions on the same record.
- Request/assign roles with correct scope (org-based).
- Troubleshoot missing task/button safely.
- Ensure approvals route to the intended roles.
- Align API/integration access with security policies.
8) Happy path workflow #1: Troubleshoot “missing action/button”
Use this when someone says “I can’t see the action everyone else has.” Goal: isolate whether it’s navigation, object context, or security.
- Confirm the user is on the correct object (worker vs position vs org).
- Confirm they’re using the same tenant/environment (prod vs sandbox).
- Have them search the task name directly (Search) to rule out UI placement.
- Compare with a known-good user: same org scope and same role?
- Check whether the action is tied to a business process policy step.
- Escalate to security admin with specifics: user, object, task, org, timestamp.
Expected outcome: You can state “navigation issue” vs “security role/scope issue” and route to the right owner.
9) Happy path workflow #2: Onboard a new role (admin)
Use when a new team or function needs Workday access.
- Define responsibilities and minimum tasks needed.
- Map responsibilities to security roles/groups (existing first).
- Define scope (which orgs/workers) for that role assignment.
- Test with a pilot user in sandbox/training tenant.
- Verify domain data visibility and task permissions.
- Verify business process routing/approval steps with that role.
- Roll out broadly and document a “request access” process.
Expected outcome: New users can perform required tasks without seeing unnecessary sensitive data.
10) Decision points
| Situation | If A… | If B… |
|---|---|---|
| User can view data but can’t act | Likely business process policy permission is missing. | Or the user is on wrong object/context; confirm record type. |
| User can act but can’t view needed fields | Likely domain security is missing for required fields. | Or field is conditionally hidden; verify eligibility conditions. |
| Integration/API request fails | Check service permissions and security group for integration user. | Or service not enabled for tenant; confirm API exposure first. |
| Over-permission risk | Reduce scope or split roles into smaller, safer groups. | Use approval/audit controls to compensate (but prefer least privilege). |
11) Common mistakes (and how to avoid)
- Mistake: Granting broad roles “just to fix it.” Avoid: least privilege + correct scope.
- Mistake: Troubleshooting without specifics. Avoid: capture user, task, object, org, time.
- Mistake: Confusing domain vs business process security. Avoid: diagnose: view data vs perform action.
- Mistake: Not testing in sandbox. Avoid: pilot and validate before broad rollout.
- Mistake: Forgetting integration users need security too. Avoid: treat integrations as users with scoped roles.
12) Permissions & Roles
Security roles enable users to review, act, or approve tasks and support organizations to which the role is assigned.
- Keep a role catalog: what role is for which job.
- Document scope rules (which orgs it covers).
- Review roles periodically (remove unused access).
- Use separation of duties for sensitive actions.
13) Data & Integrations
APIs/services enforce security; integration access should align with domain and business process policies.
14) What good looks like
- Users have only the access they need, scoped correctly.
- Approvals route reliably to roles, not individuals.
- Security changes are auditable with clear justification.
- Integrations follow the same least-privilege approach.
15) Checklist: Pre-check + Post-check
Pre-check
- Defined required tasks and data scope.
- Identified appropriate existing roles/groups.
- Confirmed org scope rules.
- Confirmed approval routing requirements.
- Planned test cases in sandbox.
Post-check
- User can perform required tasks end-to-end.
- User cannot access unrelated sensitive data.
- Inbox approvals appear for correct people/roles.
- Audit trail and documentation are updated.
- Integration users validated (if applicable).
16) Practice lab (5–15 min)
Goal: practice diagnosing security without over-granting access.
- Pick one common task (e.g., approve time off) and list required roles.
- Simulate a “missing action” case and fill a troubleshooting template: user/task/object/org/time.
- Propose the minimum role/scope change to fix it.
- Write a short rollback plan (remove role if over-granted).
Verify you did it right: Your fix statement is precise (what role, what scope, what permission type) and avoids broad access.
17) Official docs links
- Workday security roles overview (example institutional guide).
- Business process framework (roles and routing logic in workflows).
Business Processes & Approvals (BPF)
Quick scanRead time: ~10–14 min
Focus: the “if this, then that” workflow engine
- Understand Workday’s Business Process Framework (BPF) as built-in workflow automation.
- Learn how events trigger steps, routing, and approvals.
- Practice reading an approval task and predicting next steps.
- Apply guardrails: don’t bypass controls; use configuration correctly.
1) Purpose / Outcome
The Business Process Framework (BPF) is the workflow engine that runs end-to-end processes and everyday tasks in Workday. Your outcome is to understand how processes are triggered, routed, and completed—so you can troubleshoot and design safer flows.
- Explain approvals as rules-based routing triggered by events.
- Identify which role owns each step (not just individuals).
- Predict what happens after you click Submit/Approve.
- Reduce stuck processes by designing clear routing paths.
2) Who this is for + When to use
This is for HRIS admins, process owners, and power users who manage approvals and workflows. Use it when approvals are confusing, processes get stuck, or you’re rolling out new transactions.
- Admins: configure steps, conditions, and role routing.
- Managers: understand why approvals route to you and what you’re approving.
- HR: ensure compliance steps are present and auditable.
- Use after policy changes (comp, leave, hiring) that require workflow updates.
3) Where in navigation + Related tabs
BPF is usually accessed via admin tasks and also experienced through Inbox tasks. Related tabs: Security Core HCM Recruiting Absence.
- Users: Inbox items represent active business process steps.
- Admins: configuration tasks (tenant-specific names) define routing rules.
- Status/history views help trace where a process is pending.
- Role assignments and org scope affect who receives steps.
4) Mental model / Flow
Think of BPF as an “if this, then that” engine triggered by events in your organization, where you choose rules and logic.
- Event triggers a business process (e.g., hire initiated).
- Process runs steps (review, approvals, docs, notifications).
- Steps route to roles based on conditions and org scope.
- Completion updates records and logs the audit trail.
Expected outcome: Processes are consistent, auditable, and aligned with policy without manual chasing.
5) Objects & Terms
- Business Process: workflow definition for an event.
- Step: approval/review/action sub-task in the process.
- Condition Rule: logic to include/skip steps based on data.
- Routing: how work goes to roles/users.
- Notifications: alerts/messages triggered by steps.
- Audit Trail: recorded history of who did what, when.
6) State machine / Lifecycle
A process typically moves through states as steps complete.
- Initiated: created by event/task submit.
- In progress: one or more steps pending in Inbox.
- On hold: blocked by missing data or external dependency (tenant-specific).
- Completed: all required steps finished; record updates applied.
- Cancelled/Denied: stopped; outcomes depend on configuration.
7) Core jobs-to-be-done
- Trace why a process routed to a specific approver.
- Identify where a process is stuck and who owns the next step.
- Design conditions to route steps based on org/amount/type.
- Ensure separation of duties for sensitive actions.
- Improve user experience by reducing unnecessary steps.
8) Happy path workflow #1: Trace a stuck process (power user)
Use this when a request is “pending forever.” Goal: identify next owner and missing inputs.
- Open the submitted request record (or use Search to find it).
- Locate the process status/history view (if enabled in tenant).
- Identify the current pending step and assigned role/user.
- Check for missing attachments/fields or failed validations.
- Message the owner with clear context (what, why, due date).
- If routing seems wrong, escalate to admin with evidence.
Expected outcome: The request moves forward or you have a clear admin ticket with step/role details.
9) Happy path workflow #2: Reduce approval noise (admin)
Use this when users complain about too many approvals. Goal: keep controls but remove unnecessary friction.
- Pick one business process (e.g., time off, hire, comp change).
- List required compliance/controls that must remain.
- Review step conditions: which steps fire too often?
- Adjust routing conditions to target only relevant cases.
- Test in sandbox with real scenarios (A/B comparisons).
- Roll out and monitor completion time and error rates.
Expected outcome: Faster completion times without losing required approvals or auditability.
10) Decision points
| Situation | If A… | If B… |
|---|---|---|
| Routing should be role-based | Use roles tied to org scope to avoid single-person bottlenecks. | If unavoidable, define backups/delegations (tenant-specific options). |
| Conditional approvals | If threshold-based (amount/risk), add clear conditions. | If not threshold-based, keep minimal stable routing for consistency. |
| Compliance step needed | Keep step mandatory; add guidance text to reduce errors. | If not required, remove or make conditional to reduce noise. |
| Process changes impact many teams | Communicate release notes and training for changed steps. | If small change, still pilot and monitor metrics post-release. |
11) Common mistakes (and how to avoid)
- Mistake: Hard-coding individuals in routing. Avoid: route to roles with org scope.
- Mistake: Over-approving everything. Avoid: add conditions so steps trigger only when needed.
- Mistake: No pilot testing. Avoid: test in sandbox with edge cases.
- Mistake: Removing controls to speed things up. Avoid: keep compliance steps; optimize conditions instead.
- Mistake: Poor user guidance. Avoid: add instruction text/checklists in steps where errors happen.
12) Permissions & Roles
BPF steps route based on roles and security; proper configuration depends on role assignments and access policies.
13) Data & Integrations
Integrations often trigger or depend on business processes; align service/API actions with workflow approvals to avoid bypassing controls.
14) What good looks like
- Users understand why approvals appear and what they’re approving.
- Processes rarely get stuck; owners are clear.
- Routing is role-based with backups, not person-based.
- Audit trail is complete and supports compliance.
15) Checklist: Pre-check + Post-check
Pre-check
- Defined trigger event and required outcomes.
- Identified mandatory compliance steps.
- Configured routing roles and org scope.
- Added clear step guidance text.
- Prepared sandbox test scenarios (happy + edge cases).
Post-check
- Metrics improved (cycle time, fewer errors).
- Approvals route to correct owners.
- No new security exposure introduced.
- Users have updated training/notes.
- Audit trail looks correct in completed cases.
16) Practice lab (5–15 min)
Goal: learn to describe a workflow change clearly.
- Pick one process you often see in Inbox (time off, hire, change request).
- Write its steps in 6–8 bullets (who does what, in order).
- Identify 2 pain points (delay, confusion, rework).
- Propose 1 condition-based improvement and 1 guidance improvement.
Verify you did it right: Someone else can read your proposal and understand trigger, routing, and expected outcome.
17) Official docs links
- Workday Business Process Framework datasheet (official overview).
- Workday “HCM can do what” PDF mentions flexible business processes and workflow visualization.
Reporting & Workforce Analytics (High-level)
Quick scanRead time: ~8–12 min
Focus: safe reporting habits + decision use
- Understand why reporting is central: decisions across plan-to-hire through retire depend on reliable data.
- Learn the difference between “lists/reports” and “transactions” (don’t edit via exports).
- Practice filters, validation, and safe sharing rules.
- Know when you need HRIS/analytics help vs self-service.
1) Purpose / Outcome
Reporting and analytics help you make faster, better decisions about workforce planning and HR outcomes. Your outcome is to produce accurate, policy-compliant reports and use them responsibly.
- Find the right report (not a look-alike) and apply correct filters.
- Validate results against known totals or samples.
- Share only what recipients are authorized to see.
- Use reports to drive action (follow-up tasks, approvals, planning).
2) Who this is for + When to use
Managers use reporting for team metrics; HR uses it for compliance and planning; executives use it for workforce decisions. Use it when planning, tracking cycle completion, or validating changes.
- Manager: headcount, absence patterns, team changes tracking.
- HR: hiring funnels, policy compliance, data quality audits.
- Leadership: workforce planning indicators and trends.
- Use after major changes (reorg, hiring push, policy updates).
3) Where in navigation + Related tabs
Common entry points: Reports worklet/app, Search for report names, dashboards (tenant-specific). Related: Core HCM Absence Business Processes Security.
- Use Search with keywords like “Headcount”, “Time Off”, “Hiring”.
- Save filters (if allowed) for repeatable reporting.
- Prefer dashboards for recurring reviews (if enabled).
- Use exports carefully and store/share securely.
4) Mental model / Flow
Reports are a read layer over governed data. Transactions change data through business processes; reports measure/monitor outcomes.
- Define the question (what decision will this support?).
- Choose the correct report and apply scope filters.
- Validate accuracy with spot checks and totals.
- Act on findings (follow-up tasks, approvals, planning actions).
Expected outcome: Reports lead to correct decisions without data leaks or misinterpretations.
5) Objects & Terms
- Report: structured output based on data sources (tenant-defined).
- Dashboard: curated set of metrics (tenant-defined).
- Prompt/Filter: parameters that scope report output.
- Export: extraction to file; increases data leak risk.
- Security: controls what data appears in reports.
6) State machine / Lifecycle
Not applicable for this tool/tab (reports don’t have a universal lifecycle in publicly available official sources; tenant-specific).
7) Core jobs-to-be-done
- Run a headcount or org report with correct scope.
- Track completion of a process/cycle (hiring, absence approvals).
- Identify anomalies (missing data, unusual trends).
- Export and share safely (authorized recipients only).
- Provide evidence for audits/compliance (where required).
8) Happy path workflow #1: Run a scoped team report (manager)
Use when you need accurate team info quickly.
- Search for a team/org report (e.g., “My Team”, “Headcount”).
- Confirm the scope prompt matches your supervisory org.
- Apply date/effective filters if the report supports it.
- Review totals and scan for obvious outliers.
- Spot-check 2–3 records against worker profiles.
- Export only if necessary; store securely per policy.
Expected outcome: You have an accurate view of your team and can act on it (planning/approvals).
9) Happy path workflow #2: Track a workflow outcome (HR/ops)
Use when you need to ensure processes are moving (e.g., absence approvals or hiring steps).
- Pick a process metric (pending approvals, aged requests).
- Run the relevant report/dashboard (tenant-specific).
- Filter to “pending” and sort by age/priority.
- Identify owners (roles/users) of next steps.
- Send targeted reminders with context and due dates.
- Re-run report to verify reduction in backlog.
Expected outcome: Backlog decreases and process cycle time improves without manual guesswork.
10) Decision points
| Situation | If A… | If B… |
|---|---|---|
| Report shows unexpected numbers | Validate prompts/filters; check effective dates. | If still off, escalate to HRIS/analytics with examples. |
| Need to share data | If recipients are authorized, share minimal necessary fields. | If not authorized, provide aggregate metrics instead. |
| Export needed? | If yes, export and store securely with retention rules. | If no, keep inside Workday to reduce leakage risk. |
| Use report for decisions | If decision is high-stakes, require second validation. | If low-stakes, proceed with documented assumptions. |
11) Common mistakes (and how to avoid)
- Mistake: Running reports with default prompts. Avoid: set scope filters intentionally.
- Mistake: Treating exports as source of truth. Avoid: use Workday as system of record; re-run for latest.
- Mistake: Sharing sensitive data widely. Avoid: follow security and least-privilege.
- Mistake: Not validating anomalies. Avoid: spot-check against worker records.
- Mistake: Confusing transactions with reports. Avoid: edits happen via tasks + business processes.
12) Permissions & Roles
Report visibility is governed by security roles and scope. If you can’t see a report, it may be a permissions issue rather than missing functionality.
13) Data & Integrations
If your org uses APIs to pull analytics, align with official service catalogs and security rules.
14) What good looks like
- Reports are repeatable (saved prompts) and validated.
- Decisions reference clear scope and effective dates.
- Data sharing follows authorization and minimal exposure.
- Reporting drives action (not just screenshots).
15) Checklist: Pre-check + Post-check
Pre-check
- Defined the decision question.
- Selected correct report/dashboard.
- Set scope prompts (org/time/status).
- Planned validation spot-checks.
- Confirmed sharing requirements.
Post-check
- Validated totals and sample records.
- Documented assumptions and filters used.
- Shared only authorized outputs.
- Triggered follow-up actions from findings.
- Stored exports securely (if any).
16) Practice lab (5–15 min)
Goal: practice safe reporting with validation.
- Pick a report you can access (e.g., “My Team”).
- Run it with two different scopes and compare results.
- Spot-check 3 entries against worker profiles.
- Write a one-paragraph summary: scope, findings, action.
Verify you did it right: Someone can reproduce your results using your documented prompts and filters.
17) Official docs links
- Workday HCM overview references workforce planning & analytics as a product area.
- Workday framing of end-to-end employee journey (plan to hire → retire).
Integrations & APIs (REST Directory)
Quick scanRead time: ~10–14 min
Focus: official service catalog + safe integration habits
- Learn how to use the official REST Directory to understand available services.
- Map a business need to the correct service (e.g., Absence Management service).
- Understand security implications: integrations must follow least privilege too.
- Build a safe integration workflow: design → test → monitor.
1) Purpose / Outcome
Integrations connect Workday with other systems (time, payroll, identity, analytics). Your outcome is to identify the right official API/service, implement safely, and avoid bypassing Workday controls.
- Find the service in the official directory and read its purpose.
- Confirm which actions are supported (read vs request vs update).
- Design security and audit requirements upfront.
- Test end-to-end with realistic data and failure cases.
2) Who this is for + When to use
This is for integration developers, HRIS, and platform/security owners. Use it when you need to pull data, push requests (like time off), or integrate third-party tools.
- Developers: implement API calls and error handling.
- HRIS: ensure data governance and alignment with business processes.
- Security: enforce least privilege for integration users.
- Use before starting a new integration to confirm service availability.
3) Where in navigation + Related tabs
Official REST Directory is publicly accessible as a service catalog; tenant configuration determines what you can actually use. Related: Security Business Processes Absence Reporting.
- Start with the directory to locate the right service domain.
- Confirm how the service aligns to a module (e.g., Absence Management).
- Confirm authentication/authorization approach in your org (tenant-specific).
- Align API actions with business process approvals (don’t bypass policy).
4) Mental model / Flow
A safe integration is a product: define outcomes, map to services, enforce security, test, and monitor. Services may allow reading data and, in some cases, submitting requests that mirror UI actions.
- Define the business use-case and required objects.
- Find the correct Workday service in the REST Directory.
- Design auth/security for an integration user (least privilege).
- Implement + test in sandbox, then monitor in production.
Expected outcome: Integration works reliably without exposing sensitive data or bypassing approvals.
5) Objects & Terms
- Service: a functional API area (e.g., Absence Management).
- Endpoint: a specific URL/method for an operation.
- Integration User: non-human account for API access.
- Scope/Permissions: what data and actions are allowed.
- Monitoring: logs, retries, alerts, and audit.
- Directory: official catalog of REST services.
6) State machine / Lifecycle
Integrations should have a lifecycle like any system component.
- Design → Implement → Test → Release → Monitor → Improve.
- Versioning and backward compatibility should be planned.
- Failures should be handled with retries and dead-letter processes.
- Exact API lifecycle/versioning is tenant and Workday release dependent.
7) Core jobs-to-be-done
- Find the correct service for a domain need (absence, worker, etc.).
- Confirm what operations are supported (read vs request).
- Design secure access for the integration user.
- Build robust error handling and monitoring.
- Validate compliance/audit requirements.
8) Happy path workflow #1: Discover a service and validate fit
Use when you’re starting an integration and need to confirm Workday support.
- Open the REST Directory and search for your domain (e.g., “Absence”).
- Read the service description to confirm supported actions.
- List required objects/fields and map them to service concepts.
- Identify security implications (sensitive data, approvals).
- Confirm with HRIS/admin that service is enabled/usable in your tenant.
- Write an API contract: inputs, outputs, errors, audit expectations.
Expected outcome: You have a clear “yes/no” on feasibility and a contract for implementation.
9) Happy path workflow #2: Implement “request time off” integration (example)
Example only: align with your tenant’s approved approach. Goal: submit a request via official service without bypassing policy.
- Confirm your tenant allows API-driven time off requests.
- Create/assign an integration user with least privilege.
- Use the Absence Management service to submit the request operation.
- Ensure approval workflow triggers as it would in UI (if applicable).
- Log request ID/status and surface it to the calling system.
- Handle failures with retries and idempotency safeguards.
- Monitor outcomes and reconcile statuses periodically.
Expected outcome: Requests are created reliably and remain governed by approvals and audit trail.
10) Decision points
| Situation | If A… | If B… |
|---|---|---|
| Need to write data vs read only | If write is supported, ensure approvals/policies still apply. | If not supported, redesign to read-only or use UI/other mechanisms. |
| Security risk level | If sensitive, restrict scopes and add monitoring/alerts. | If low-risk, still apply least privilege and logging. |
| Real-time vs batch | If real-time required, design for rate limits and resilience. | If batch is fine, schedule jobs and reconcile periodically. |
| Audit/compliance needs | If strict, store immutable logs and correlation IDs. | If standard, keep structured logs and retention policy. |
11) Common mistakes (and how to avoid)
- Mistake: Treating integration users like admins. Avoid: least privilege and scoped roles.
- Mistake: Bypassing approvals. Avoid: align API actions with business processes and policy.
- Mistake: No idempotency. Avoid: design to prevent duplicate creates on retry.
- Mistake: Weak monitoring. Avoid: alerts, dashboards, and reconciliation.
- Mistake: Not involving HRIS/security early. Avoid: co-design security and data governance.
12) Permissions & Roles
API access should be governed by security roles/groups like any user. Integration users should have only required domain and process permissions.
13) Data & Integrations
The REST Directory explicitly lists services, including Absence Management capabilities such as accessing leave/time-off details and requesting time off/leaves.
- Use directory descriptions to map features to services.
- Confirm tenant enablement and authentication approach.
- Document data classification and allowed consumers.
- Establish retention and audit logging for API calls.
14) What good looks like
- Integration is resilient (retries, idempotency, monitoring).
- Security is minimal and scoped; no accidental data exposure.
- Approvals/policies are respected; audit trail is clear.
- Clear ownership and runbooks exist for incidents.
15) Checklist: Pre-check + Post-check
Pre-check
- Confirmed official service exists for the use-case.
- Confirmed tenant enablement and constraints.
- Defined integration user security scope.
- Designed idempotency and retry strategy.
- Defined logging, monitoring, and audit needs.
Post-check
- Tests pass (happy + edge cases).
- Approvals/policies behave as expected.
- Monitoring/alerts are live and meaningful.
- Runbook and ownership are documented.
- Periodic reconciliation confirms data consistency.
16) Practice lab (5–15 min)
Goal: practice mapping a requirement to a service contract.
- Pick one need: “request time off” or “pull absence balances.”
- Find the related service in REST Directory and copy key capability statements into your notes.
- Draft an API contract: inputs, outputs, error cases, audit fields.
- List minimum security permissions you think are needed.
Verify you did it right: A teammate can implement from your contract without guessing, and security is clearly scoped.
17) Official docs links
- Workday REST Directory (official listing of REST services).
- Workday Absence Management capabilities (product overview).
Mobile & Employee Self-Service (High-level)
Quick scanRead time: ~7–10 min
Focus: quick tasks safely on the go
- Learn what self-service typically includes: inbox tasks, profile, time off (tenant-dependent).
- Build a “mobile safe list” of actions you can do confidently.
- Know when to switch to desktop (complex transactions, validation).
- Apply security hygiene: device access and sensitive data.
1) Purpose / Outcome
Mobile and self-service aim to make common tasks fast and accessible. Your outcome is to complete routine actions (approvals, time off requests, profile updates) without mistakes or security risks.
- Use Inbox to action approvals quickly.
- Submit simple requests (time off) correctly.
- Check status and notifications without hunting through menus.
- Keep sensitive data safe on personal devices.
2) Who this is for + When to use
Employees and managers who need quick actions away from desktop. Use it for routine tasks, not for complex configuration or high-risk changes.
- Employee: request time off, update contact info (if allowed).
- Manager: approve time off/hiring steps (if allowed).
- Use when traveling or when you need quick approvals.
- Switch to desktop for complex reviews, attachments, or large data checks.
3) Where in navigation + Related tabs
Mobile typically mirrors core worklets and Inbox. Related: Overview Absence Security.
- Start: Inbox for tasks/approvals.
- Use Search (if available) for task discovery.
- Use Time Off/Absence area for requests and balances.
- Use profile/self-service pages for permitted updates.
4) Mental model / Flow
Mobile is best for short workflows: open task → validate key fields → approve/submit → confirm status. Complex validation should happen on desktop.
- Open Inbox item or start a simple request.
- Validate essentials (dates, person, type, amounts if applicable).
- Act (approve/submit) with brief comment if needed.
- Confirm status and follow-up tasks.
Expected outcome: Fast completion of routine work with minimal errors.
5) Objects & Terms
- Inbox: task/approval queue.
- Notifications: prompts to act or review.
- Self-service: employee-permitted changes.
- Mobile security: device lock, secure storage, session timeout (org policy).
- Absence request: common mobile workflow.
6) State machine / Lifecycle
Not applicable for this tool/tab (mobile UX varies by tenant and device; publicly available official sources in this run don’t define a universal mobile lifecycle).
7) Core jobs-to-be-done
- Approve/deny an Inbox item quickly.
- Request time off and check balances.
- View personal profile details and status of requests.
- Receive notifications and act before deadlines.
- Escalate complex issues to desktop/support.
8) Happy path workflow #1: Mobile approval (manager)
Use when you need to approve time off or similar routine approvals.
- Open Inbox on mobile.
- Select the approval item and open details.
- Check key fields (dates/type/person/notes).
- Check overlap/coverage if visible (otherwise defer to desktop).
- Approve or deny with a short comment if needed.
- Confirm completion status.
Expected outcome: Approval is recorded and routed to the next step without delays.
9) Happy path workflow #2: Request time off (employee)
Use when you need a quick time off request.
- Open Time Off/Absence area.
- Select absence type and dates.
- Review balance impact (if shown).
- Add note for manager context.
- Submit and confirm status.
- Check request history/status later.
Expected outcome: Request is submitted and routed for approval per policy.
10) Decision points
| Situation | If A… | If B… |
|---|---|---|
| Need to review attachments | If attachments are readable, review then act. | If not, switch to desktop before approving. |
| Complex compensation/hiring approval | If you can validate key numbers and context, proceed cautiously. | If not, defer and review on desktop with full info. |
| Public device / shared Wi-Fi | If unavoidable, avoid sensitive actions and log out immediately. | If possible, wait for secure network or use desktop securely. |
| Missing action on mobile | If it exists on desktop, use desktop (mobile may limit UI). | If missing everywhere, troubleshoot as a security/role issue. |
11) Common mistakes (and how to avoid)
- Mistake: Approving complex items on a small screen. Avoid: move to desktop for high-risk approvals.
- Mistake: Using mobile without device lock. Avoid: enable strong lock and follow org policy.
- Mistake: Ignoring status confirmation. Avoid: always confirm submitted/approved state.
- Mistake: Acting on wrong person/request. Avoid: double-check name/object before approving.
- Mistake: Storing exports/screenshots. Avoid: avoid capturing sensitive data on device.
12) Permissions & Roles
Mobile visibility still depends on the same security roles and scope as desktop.
13) Data & Integrations
Not applicable for this tool/tab (mobile integration details vary by tenant; not specified in publicly available official sources in this run).
14) What good looks like
- Routine tasks are completed quickly and correctly on mobile.
- High-risk actions are deferred to desktop review.
- Users follow security hygiene (locks, logout, minimal exposure).
- Status and next steps are always confirmed.
15) Checklist: Pre-check + Post-check
Pre-check
- Device is locked and secure.
- Network is safe enough for the action.
- Action is routine (low-risk) and readable on mobile.
- I can validate key fields.
- I know what next steps should happen.
Post-check
- Status shows approved/submitted.
- No sensitive screenshots/files were stored.
- Follow-up tasks are noted (Inbox).
- I logged out if on a shared device/network.
- I can reproduce the action later if needed.
16) Practice lab (5–15 min)
Goal: build a safe mobile routine.
- Open Inbox and identify 1 low-risk task you can handle on mobile.
- Locate Time Off/Absence and find balance/status views.
- Write your personal “mobile safe list” (3 actions) and “desktop only list” (3 actions).
- Verify you can find help/support link in-app (if present).
Verify you did it right: You can complete routine tasks without confusion and know when to switch to desktop.
17) Official docs links
- Workday Absence Management highlights mobile self-service as a key capability.
Getting Started (Employee Journey View)
Quick scanRead time: ~8–12 min
Focus: from plan-to-hire to retire
- Use the “employee journey” framing to understand where each Workday HCM area fits.
- Learn the beginner path: navigation → core record → common requests → approvals.
- Set your first-week success checklist (what to learn + what not to touch).
- Connect cross-tabs so you always know “where next”.
1) Purpose / Outcome
This tab gives a guided learning path for new users using Workday’s employee journey framing. Your outcome is to confidently complete your first-week tasks and know which module to use for each need.
- Understand plan-to-hire → hire-to-pay → develop → manage time → retire framing.
- Identify your role (employee/manager/HR) and likely tasks.
- Build a “daily loop”: Inbox + quick checks.
- Know how to ask for help with good context (task/object/status).
2) Who this is for + When to use
For anyone new to Workday HCM. Use it on Day 1 and any time you feel lost about which module or tab to use.
- Employees starting self-service tasks.
- Managers receiving first approvals.
- HR/ops onboarding into process ownership.
- Use before you attempt sensitive changes (pay, security, org moves).
3) Where in navigation + Related tabs
Start with Overview & Navigation, then branch based on your job. Related tabs are all others in this guide.
- Week 1 sequence: Overview → Core HCM → Absence → (Manager: Recruiting) → Security (as needed).
- Use Business Processes tab to understand approvals and routing.
- Use Reporting tab to validate outcomes and track completion.
- Use Integrations tab if you’re building systems around Workday.
4) Mental model / Flow
Workday HCM supports the employee journey end-to-end: plan to hire, hire to pay, and ongoing lifecycle operations.
- Plan-to-hire: planning and recruiting decisions.
- Hire: candidate → offer → worker record.
- Operate: time off, changes, approvals and workflow.
- Improve: reporting and analytics to make decisions.
Expected outcome: You can map any request you have to the right Workday area.
5) Objects & Terms
- Home/Worklets: entry points by function.
- Search: task discovery.
- Inbox: approvals and follow-up tasks.
- Business Process: workflow behind submissions.
- Security Role: controls access by role/scope.
6) State machine / Lifecycle
Most requests follow a consistent lifecycle: draft → submit → approvals → complete. The labels vary but the pattern is stable.
- Draft: safe to revise.
- Submitted: routed into workflow.
- Pending: waiting in someone’s Inbox.
- Completed/Denied: final outcome recorded.
- If unclear, use status/history views or ask HRIS.
7) Core jobs-to-be-done
- Find and complete your first Inbox tasks.
- Locate your worker profile and verify key info.
- Request time off and check balance/status.
- Understand what approvals mean and who owns next step.
- Know when to escalate to HR/security/admin.
8) Happy path workflow #1: Day 1 onboarding loop
A safe “Day 1” routine that builds confidence without risky changes.
- Open Home and identify your key worklets/apps.
- Open Inbox and read any tasks; don’t approve blindly.
- Open your worker profile and verify basic fields (org/manager/contact).
- Find Time Off/Absence and view balance and request history.
- Search for 1 common “View” report and learn filters.
- Write down where to get help (HR/support link) and what info to provide.
Expected outcome: You can navigate, find tasks, and understand next steps without causing accidental changes.
9) Happy path workflow #2: Manager first-week approvals loop
For managers who start receiving approvals immediately.
- Review Inbox daily and sort by due date/impact.
- For each item, open details and validate key fields.
- Check coverage/overlap for time off approvals.
- For hiring items, verify org/position and start date alignment.
- Approve/deny with comments when necessary.
- Track status and follow-up tasks to completion.
Expected outcome: Approvals move quickly without mistakes, and your team experiences fewer delays.
10) Decision points
| Situation | If A… | If B… |
|---|---|---|
| You’re unsure what a task does | If you can open details safely, read and validate before acting. | If still unclear, pause and ask HR/owner with task details. |
| You need to change sensitive data | If authorized, use official transaction task with approvals. | If not authorized, stop and request via HR/security process. |
| Something is stuck | If you can see owner/step, nudge with context. | If you can’t, escalate to HRIS/support for tracing. |
| Feature not available in your tenant | Use your org’s alternative process. | Mark as N/A; don’t assume Workday supports it in your tenant. |
11) Common mistakes (and how to avoid)
- Mistake: Skipping Inbox. Avoid: check daily; it’s your work queue.
- Mistake: Trying random tasks until one works. Avoid: search task names and read required fields.
- Mistake: Approving without validation. Avoid: open details and confirm key fields.
- Mistake: Making changes outside approved processes. Avoid: use business processes for audit and routing.
- Mistake: Assuming your tenant matches a tutorial. Avoid: confirm what’s enabled in your environment.
12) Permissions & Roles
What you can do depends on security roles and org assignment. If you can’t see something, it may be a permissions issue.
13) Data & Integrations
If your org builds integrations, rely on official service catalogs and respect security and business process controls.
14) What good looks like
- You know where to start (Home/Search/Inbox) for most tasks.
- You understand the employee journey framing and module mapping.
- You avoid risky changes and escalate correctly.
- You can explain status and next steps for submitted items.
15) Checklist: Pre-check + Post-check
Pre-check
- Identified my role and common tasks.
- Located Inbox and Home worklets/apps.
- Found my worker profile and key fields.
- Identified Time Off/Absence area.
- Found support/help route in my tenant.
Post-check
- Completed/understood initial Inbox tasks.
- Verified profile data is accurate.
- Can request time off and check status.
- Can explain why approvals happen (BPF).
- Know when to escalate to HR/security.
16) Practice lab (5–15 min)
Goal: map common needs to Workday areas.
- Write 5 common needs (e.g., “update phone”, “request leave”, “approve time off”, “hire a person”, “see headcount”).
- For each, write where you’d start: Home worklet vs Search vs Inbox.
- Pick one and execute a safe view-only exploration (no sensitive submits).
- Share your map with a teammate and compare differences.
Verify you did it right: Your mapping matches how tasks and approvals actually show up in your tenant.
17) Official docs links
- Workday “employee journey” framing (plan to hire → retire).
- Workday business process framework (workflow and approvals built-in).
- Workday HCM product overview (core areas).
