Why this solution was needed
New employee onboarding often starts with good intentions but quickly becomes a patchwork of emails, spreadsheets, chat messages, and one-off requests. The result is predictable: missing details, inconsistent handoffs, delays in provisioning, and too much time spent chasing down information that should have been captured correctly at the start.
To improve that process, I built a lightweight onboarding solution using Power Apps, SharePoint, and Power Automate. The goal was not to over-engineer the experience, but to create a structured, practical front-end that made onboarding requests easier to submit and much easier to act on.
The result was a centralized process that captured onboarding details in a consistent way, triggered an approval workflow, and then kicked off a series of downstream actions to support provisioning, notifications, task creation, and operational follow-up.
Solution architecture at a glance
The implementation was built around three core components:
- Power Apps Canvas App for request submission
- SharePoint List as the system of record
- Power Automate Flow to drive approvals and downstream automation
Hiring Manager / HR → Power Apps Form → SharePoint List → Approval → Provisioning / Notifications / Tasks
The SharePoint list design
The SharePoint list served as the foundation for the entire process. Rather than relying on free-form notes or inconsistent email requests, the list standardized the exact information required for a new hire request.
Some of the captured fields included:
- Identity details: first name, last name, phone number, address
- Role information: job title, department, leadership indicator
- Licensing needs: Microsoft 365 licensing, Visio, JIRA, and related tool requirements
- Hardware selection: laptop platform such as Windows or macOS
- Timing: onboarding due date / start date
- Additional notes: manager, personal email, comments, and special onboarding instructions
This structure created a much better handoff between the requestor and the teams responsible for completing the work. It also made the downstream automation significantly more reliable, because the flow was working with predictable, validated fields instead of loosely formatted requests.
The Power Apps Canvas App experience
The Canvas App was built to give users a straightforward intake experience. Instead of editing the list directly, requestors could open the app, fill out the form, select from standardized values, and submit the onboarding request in a cleaner and more controlled way.
The biggest value of the app was not visual polish for its own sake, but the ability to guide users through the required fields and reduce missing information. Dropdowns, default values, and clearly labeled form inputs made the request process much easier to complete correctly the first time.
What happened after submission
Once the Power Apps form submitted a new item into SharePoint, a Power Automate flow took over. The flow began when a new list item was created and then initialized variables used later in the process, including comments and a random number value that could be used for tracking or related logic.
After that, the onboarding request entered an approval stage. This created a checkpoint before provisioning actions began, which helped make sure requests were reviewed before accounts, access, or related tasks were created.
The approval pattern
One of the strengths of the solution was the way the approval logic was used to control the process. If a request was rejected, the flow could notify the requester and remove the list item so incomplete or invalid requests would not linger in the system.
If the request was approved, the process moved forward into the operational onboarding steps. This kept the workflow simple, understandable, and easy to troubleshoot.
Rejected request → send notification → clean up request
Approved request → continue onboarding automation
Automating onboarding tasks
The real value of the workflow came from what happened after approval. Instead of stopping at a notification, the automation continued into actions that supported the onboarding team and helped standardize the next steps.
The flow design included activities such as:
- Creating a user account
- Adding the user to a baseline group
- Sending email notifications to the onboarding team
- Retrieving supporting policy documents
- Sending a welcome email to the onboarding user
- Creating a group event
- Creating a Planner task for onboarding follow-up
- Updating task details with contextual notes
- Creating a JIRA issue for related operational work
- Applying additional conditional steps based on requested services or licensing
That combination helped transform the process from “submit a form and hope someone follows up” into a more guided and auditable operational workflow.
Examples of downstream orchestration
Beyond account creation, the workflow supported several practical onboarding activities that often get missed when handled manually:
- Operational notifications: the onboarding team received a clear summary of the request
- Document delivery: policy and handbook files could be included in onboarding communications
- Task visibility: Planner tasks made work easier to track and assign
- Cross-platform coordination: JIRA tickets extended the process into broader operational teams
- Conditional branching: optional items such as licensing or group assignments could be handled only when needed
Why this approach worked well
This type of solution works especially well because it balances simplicity with practical business value. The form is easy to use, the data source is familiar, and the automation layer can grow over time as needs evolve.
Some of the key benefits included:
- Standardized intake: all required onboarding fields are captured consistently
- Reduced manual effort: fewer emails, fewer handoffs, and less repetitive follow-up
- Better data quality: dropdowns and structured fields reduce mistakes
- Improved visibility: onboarding tasks and status become easier to track
- Scalability: additional logic and integrations can be added without redesigning the whole process
Lessons learned
A few practical lessons stood out while building and shaping this kind of solution:
- Start with the list design. Good automation depends on clean, structured data.
- Keep the request form focused. Ask for what is needed to act, not every possible detail.
- Use approvals intentionally. A simple approval stage can prevent unnecessary downstream work.
- Think beyond account creation. The real value is in coordinating the operational tasks around onboarding.
- Build for extensibility. Expect new fields, roles, licenses, and integrations over time.
Where this can go next
Solutions like this are often a strong starting point rather than an endpoint. Once the intake and workflow foundation is in place, organizations can expand into more advanced scenarios such as:
- role-based automation for departments or business units
- automated entitlement and group assignment models
- deeper reporting through Power BI
- device readiness workflows tied to endpoint management processes
- integration with broader identity lifecycle governance approaches
Final thoughts
This was a good example of how the Power Platform can solve a very real operational problem without requiring a heavyweight custom development project. A Canvas App provided a cleaner user experience, SharePoint gave the solution a reliable and accessible data source, and Power Automate turned a manual onboarding request into a repeatable workflow with approvals, notifications, and downstream task creation.
For organizations still onboarding users through inboxes and ad hoc checklists, even a modest solution like this can create immediate improvements in consistency, speed, and accountability.