International Journal of Computer Engineering and Technology (IJCET)

Volume 13, Issue 1, January – April 2022, pp. 65-75, Article ID: IJCET_13_01_006
Available online at https://iaeme.com/Home/issue/IJCET?Volume=13&Issue=1
ISSN Print: 0976-6367 and ISSN Online: 0976–6375
Impact Factor (2022): 17.98 (Based on Google Scholar Citation)
DOI: https://doi.org/10.17605/OSF.IO/VT28H

© IAEME Publication

AUTOMATION IN WORKDAY USING PYTHON-

SELENIUM
Jayesh Jhurani
IT Manager, ServiceTitan, Cumming, USA

ABSTRACT
The research paper explores the implementation of an automated system using
Python and Selenium to streamline the benefits management process within Workday.
It delves into the challenges associated with manual administration, such as time
consumption, error susceptibility, and inefficiency in handling daily tasks like closing
and finalizing benefit groups. Through a detailed analysis, the paper demonstrates how
automation can significantly enhance operational efficiency, reduce errors, and
improve the overall employee experience by ensuring timely and accurate benefits
administration. This study underscores the value of leveraging open-source tools for
cost-effective, flexible, and scalable solutions in HR technology.
Keywords: Automation, Workday, Python, Selenium, Benefits Management

Cite this Article: Jayesh Jhurani, Automation in Workday Using Python-Selenium,

International Journal of Computer Engineering and Technology 13(1), 2022, pp. 65-75.
https://iaeme.com/Home/issue/IJCET?Volume=13&Issue=1

INTRODUCTION
In the evolving landscape of HR technology, integrating advanced automation and artificial
intelligence (AI) into Human Capital Management (HCM) systems like Workday presents a
promising frontier for enhancing operational efficiency and decision-making processes. This
paper explores the technical methodologies and benefits of deploying Python and Selenium-
based scripts for automating key HR tasks within Workday, emphasizing the enhancement of
benefits management through the strategic application of these technologies. By leveraging
Python's robust programming capabilities alongside Selenium's web automation tools, the
research delves into developing a seamless, automated workflow capable of navigating
Workday's complex interfaces, extracting and processing data, and implementing machine
learning insights into Workday Prism Analytics. This integration not only aims to streamline
HR operations but also to democratize access to predictive insights across organizational levels,
ultimately fostering a more informed and agile decision-making environment.

https://iaeme.com/Home/journal/IJCET 65 editor@iaeme.com
 Automation In Workday Using Python-Selenium

Background
Workday Benefits, a module within Workday's comprehensive cloud ERP solution, offers a
robust framework for managing employee benefits information. This system is designed to
streamline the administration of benefits across an organization, ensuring that both current
employees and new hires have access to and can manage their benefits effectively. Here's an
elaboration on how Workday Benefits facilitates these processes:

Regular Open Enrollment

Open enrollment is a period typically held once a year, during which employees can enroll in
or make changes to their benefits selections, such as health insurance, dental insurance,
retirement plans, and other employer-provided benefits. Workday Benefits allows organizations
to set up and manage this open enrollment period digitally, enabling employees to make their
elections online. This system simplifies the process by providing employees with the
information they need to make informed decisions about their benefits packages.

New Hires Open Enrollment

In addition to the annual open enrollment period, Workday Benefits recognizes the need for
new hires to elect their benefits upon joining the organization. Workday allows for a separate
open enrollment period specifically for new employees, ensuring they do not have to wait for
the annual open enrollment to make their benefits selections. This functionality is crucial for
onboarding new hires effectively, allowing them to quickly and easily enroll in the company's
benefits programs as part of their new employee orientation process.

Daily Closure and Finalization of Benefit Groups

Workday Benefits also supports the daily closure and finalization of benefit groups. This feature
is essential for maintaining accurate and up-to-date records of employees' benefits elections.
By requiring that each benefit group be closed and finalized daily, Workday ensures that all
changes made by employees to their benefits selections are captured and processed in a timely
manner. This daily process helps prevent discrepancies and ensures that employees' benefits
coverage reflects their most recent elections.

Advantages of Workday Benefits

● Streamlined Benefits Management: Workday Benefits simplifies the administration
of benefits, making it easier for HR departments to manage open enrollment periods,
track employee elections, and update benefits information.
● Enhanced Employee Experience: By providing a user-friendly platform for
employees to select and manage their benefits, Workday improves the overall employee
experience, making it easier for them to understand and take advantage of their benefits
options.
● Compliance and Accuracy: The daily closure and finalization process helps ensure
compliance with benefits policies and regulations, while also maintaining the accuracy
of benefits records.
● Flexibility for New Hires: Offering a separate open enrollment period for new hires
demonstrates an organization's commitment to their well-being from day one, allowing
them to access their benefits without delay.

https://iaeme.com/Home/journal/IJCET 66 editor@iaeme.com
 Jayesh Jhurani

Problem Statement
The problem statement addresses a significant challenge faced by HR departments in managing
employee benefits through Workday: the daily task of closing and finalizing multiple benefit
groups is both time-consuming and labor-intensive. This process, taking between 30 minutes
to an hour each day, can lead to inefficiencies and potential delays in the administration of
benefits, affecting both the HR department's productivity and the overall employee experience.
Here's an elaboration on the issues and potential implications of this problem:

Tedious and Time-Consuming Process

The requirement to close and finalize benefit groups on a daily basis demands constant attention
and manual effort from the HR staff. This routine task, while necessary to ensure the accuracy
and timeliness of benefits enrollment and changes, can become a significant drain on resources,
especially in larger organizations with a substantial number of employees.

Impact on HR Productivity
The daily commitment of up to an hour on this task diverts HR personnel from focusing on
other critical functions, such as employee engagement, training, and development, and strategic
HR initiatives. Over time, this can lead to decreased efficiency within the HR department, as
the repetitive and administrative nature of the task consumes a considerable portion of the
workday.

Potential for Errors

Manual processes, especially those that are repetitive and time-consuming, are prone to human
error. Mistakes in closing and finalizing benefit groups can lead to incorrect benefit
enrollments, delays in benefit activation, or issues with benefit providers. Such errors can have
direct implications for employees, affecting their coverage and satisfaction with the benefits
program.

Employee Experience
The efficiency and accuracy of benefits management directly impact the employee experience.
Delays or errors in processing benefits changes can lead to frustration and a lack of trust in the
HR department and the organization as a whole. For new hires, in particular, this can negatively
impact their initial impression of the company.

Potential Solutions
To address this problem, organizations can explore several strategies to streamline the process
and reduce the burden on HR staff:
● Automation: Implementing automation tools within Workday to handle routine tasks
associated with closing and finalizing benefit groups can significantly reduce the time
and effort required.
● Batch Processing: Instead of daily closures, evaluating the feasibility of batch
processing (where appropriate and compliant with regulations) could reduce the
frequency of these tasks.
● Dedicated Resources: Allocating specific resources or teams to handle benefits
administration, possibly in shifts, to ensure continuous processing without
overburdening individual staff members.

https://iaeme.com/Home/journal/IJCET 67 editor@iaeme.com
 Automation In Workday Using Python-Selenium

● Continuous Training: Regular training for HR staff on the latest Workday features and
best practices can help improve efficiency and reduce the likelihood of errors.
Addressing the challenges associated with closing and finalizing multiple benefit groups
daily requires a combination of technological solutions, process optimization, and possibly a
reevaluation of the benefits management strategy. By tackling these issues, organizations can
improve HR productivity, enhance the employee experience, and ensure the accurate and timely
administration of employee benefits.

Solution
The solution to the tedious and time-consuming process of closing and finalizing multiple
benefit groups daily involves the development and implementation of a Python script that
utilizes Selenium, a powerful tool for automating web browsers. This approach offers a strategic
way to streamline the benefits management process within Workday, significantly reducing the
manual effort required by HR personnel and enhancing overall efficiency. Here’s a detailed
look at how this solution works and its potential benefits:

Selenium and Its Role in Automation

Selenium is an open-source framework designed for automated testing of web applications. It
allows for the simulation of user actions in web browsers, enabling automated interaction with
web pages. By leveraging Selenium, developers can create scripts that automatically navigate
through web pages, fill out forms, click buttons, and extract data, mimicking the actions that a
human user would take but at a much faster and more consistent pace.

Python Scripting for Automation

Python, known for its simplicity and readability, is an excellent choice for writing automation
scripts. When combined with Selenium, it provides a powerful toolkit for automating web-
based tasks. The Python script for automating the closure and finalization of benefit groups
would essentially perform the following tasks:
● Login Automation: Automatically log into the Workday system using predefined HR
credentials.
● Navigation: Navigate through the Workday interface to reach the specific sections
where benefit groups are managed.
● Data Processing: Identify benefit groups that need to be closed and finalized for the
day, possibly using criteria such as date, status, or any other relevant indicators.
● Perform Actions: Execute the necessary steps to close and finalize each benefit group,
including filling out any required forms and confirming the finalization process.
● Verification and Logging: Verify that each benefit group has been successfully closed
and finalized, logging any issues or errors encountered during the process for further
review.

Benefits of the Automated Solution

● Time Efficiency: The most immediate benefit is the significant reduction in time
required to complete daily tasks, freeing up HR personnel to focus on more strategic
and impactful work.

https://iaeme.com/Home/journal/IJCET 68 editor@iaeme.com
 Jayesh Jhurani

● Accuracy and Consistency: Automation reduces the risk of human error, ensuring that
benefit groups are closed and finalized correctly every time.
● Scalability: As the organization grows, the script can easily handle an increasing
volume of benefit groups without a proportional increase in effort or resources.
● Improved Employee Experience: Faster and more accurate processing of benefits
changes leads to higher satisfaction among employees, contributing to a positive
perception of the HR department and the organization.

Implementation Considerations
● Security and Compliance: Ensuring that the script handles sensitive data securely and
complies with data protection regulations is crucial.
● Maintenance and Updates: The script may require updates to accommodate changes
in the Workday interface or benefits management processes.
● Monitoring and Oversight: While automation can handle routine tasks, human
oversight is necessary to monitor the process, handle exceptions, and review
performance.
By automating the process of closing and finalizing benefit groups with a Python script and
Selenium, organizations can address the challenges associated with manual benefits
management in Workday, enhancing efficiency, accuracy, and the overall HR operational
workflow.

Why Python
Choosing Python and Selenium to automate the process of closing and finalizing benefit groups
in Workday, instead of opting for commercial Robotic Process Automation (RPA) tools,
presents a strategic decision driven by several compelling reasons. While RPA tools offer
powerful automation capabilities, the combination of Python and Selenium provides a cost-
effective, flexible, and open-source alternative that aligns with the needs of organizations
looking to optimize their operations without incurring significant expenses. Here’s a detailed
exploration of why Python and Selenium are chosen for this solution:

Open Source and Cost-Effectiveness

● No Licensing Fees: Python and Selenium are both open-source, meaning they are free
to use, modify, and distribute. This contrasts with commercial RPA tools, which often
come with high licensing fees. For organizations, especially small to medium
enterprises or those with budget constraints, avoiding these fees can lead to substantial
cost savings.
● Community Support: Both Python and Selenium have large, active communities.
Users benefit from a wealth of shared knowledge, including documentation, forums,
and pre-built libraries. This community support can accelerate development time and
provide solutions to common problems, further reducing implementation costs.

https://iaeme.com/Home/journal/IJCET 69 editor@iaeme.com
 Automation In Workday Using Python-Selenium

Flexibility and Customization

● Adaptability: Python’s simplicity and readability make it an ideal language for quickly
developing and deploying automation scripts. Its flexibility allows for the customization
of the automation solution to fit specific organizational needs, including the ability to
integrate with other systems and databases seamlessly.
● Extensive Libraries: Python offers a vast selection of libraries for web scraping, data
manipulation, and automation, extending beyond Selenium. This ecosystem allows
developers to tailor the solution precisely to the task at hand, enhancing the script’s
functionality and efficiency.

Development and Maintenance

● Rapid Development: Python enables rapid script development, allowing organizations
to implement automation solutions in a shorter timeframe. This speed to deployment
means that benefits can be realized sooner, contributing to quicker returns on
investment.
● Ease of Maintenance: Python scripts are easy to read and understand, making
maintenance and updates more straightforward. As Workday updates its interface or the
organization’s processes evolve, the script can be easily adjusted by internal teams,
avoiding the need for external support.

Scalability
● Handling Complexity: Python and Selenium can handle complex automation tasks,
not just simple repetitive actions. This capability ensures that as the organization’s needs
grow and processes become more complex, the automation solution can scale
accordingly.
● Versatility: The solution is not limited to a single application or task. Python and
Selenium can automate a wide range of web-based applications, making it a versatile
tool in the organization’s digital transformation toolkit.

Why Not Commercial RPA Tools?

While commercial RPA tools provide a user-friendly interface and are designed for rapid
deployment, they can be prohibitively expensive, especially for extensive implementations.
Additionally, they might not offer the same level of customization and flexibility as a solution
developed with Python and Selenium. For organizations that have the technical expertise in-
house, or for those looking to minimize costs while maintaining a high degree of control over
their automation processes, Python and Selenium present an attractive alternative.

Solution Details
The use of a Jupyter Python script to automate the closure and finalization of all benefit groups
in Workday, while simultaneously generating an Excel sheet as output, represents a
sophisticated approach to streamlining HR operations. This solution not only automates a
critical, time-consuming task but also ensures that data regarding the closure and finalization
of benefit groups is systematically recorded and accessible. Here’s a detailed elaboration on
how such a script functions and the benefits it offers:

https://iaeme.com/Home/journal/IJCET 70 editor@iaeme.com
 Jayesh Jhurani

Script Functionality
1. Login Automation: The script initiates by automating the login process to access
Workday, using credentials securely stored or entered at runtime.
2. Navigation: Utilizing Selenium, the script navigates through Workday’s web interface
to reach the sections where benefit groups are managed.
3. Identification and Closure: The script identifies all open benefit groups that require
closure and finalization for the day. This could be based on specific criteria such as date,
status, or other relevant parameters.
4. Automated Actions: For each identified benefit group, the script executes the
necessary steps to close and finalize it. This involves interacting with web elements like
forms and buttons, mimicking the actions an HR employee would take.
5. Data Collection: Throughout the process, the script collects data on each benefit group
that it processes. This data includes details such as the benefit group name, closure
status, finalization status, and any other relevant information.
6. Excel Sheet Generation: Once all benefit groups have been processed, the script uses
a Python library such as pandas or xlsxwriter to generate an Excel sheet. This sheet
includes all collected data, organizing it in a structured and readable format for review
and record-keeping.
7. Logging and Error Handling: The script includes robust error handling and logging
mechanisms to record any issues encountered during execution. This ensures that any
problems can be quickly identified and addressed.

Output Excel Sheet

● The generated Excel sheet serves as a comprehensive record of all actions taken by the
script. It can include columns for benefit group names, closure and finalization statuses,
timestamps, and any notes or exceptions encountered.
● This Excel sheet can be saved to a designated location, emailed to relevant stakeholders,
or uploaded to a shared drive for easy access and review.

Benefits of the Script

● Efficiency and Time Savings: Automates a process that would otherwise take 30
minutes to an hour each day, freeing up HR personnel for more strategic tasks.
● Accuracy and Consistency: Minimizes human error, ensuring that all benefit groups
are closed and finalized as required.
● Record-Keeping: Automatically generates a detailed record of all actions taken,
supporting transparency and accountability.
● Scalability: Can easily be adapted or expanded to handle additional tasks or changes in
process requirements.
● Cost-Effectiveness: Leverages free, open-source tools to deliver a powerful automation
solution without the need for expensive commercial software.

https://iaeme.com/Home/journal/IJCET 71 editor@iaeme.com
 Automation In Workday Using Python-Selenium

Implementation Considerations
● Security: Ensure that the script handles login credentials and sensitive data securely,
complying with data protection regulations.
● Maintenance: As Workday updates its interface, the script may require adjustments to
maintain functionality.
● Technical Expertise: Requires initial development by someone with knowledge of
Python, Selenium, and possibly Excel generation libraries.
This Jupyter Python script represents a highly effective solution to automate the closure and
finalization of benefit groups in Workday, demonstrating the potential of scripting and
automation to enhance HR operations and data management.

from selenium import webdriver

from selenium.webdriver.common.keys import
Sample Jupiter Python script Keys
import pandas as pd
import datetime

# Initialize the WebDriver and DataFrame

driver = webdriver.Firefox()
df = pd.DataFrame(columns=['Benefit_Group',
'Status', 'Count', 'Start_Time', 'End_Time'])

# Define a function to navigate and perform

actions
def process_benefit_groups():
driver.get("Your Workday Tenant URL") #
Placeholder for the actual URL
# Login omitted for brevity

start_time = datetime.datetime.now()
benefit_groups = ['Group1', 'Group2'] #
Placeholder for actual benefit group extraction
logic

for group in benefit_groups:

# Placeholder for navigating to each benefit
group's page and performing
closure/finalization actions
status = 'Success' # Placeholder for actual
status after attempting to close/finalize
count = 1 # Placeholder for the actual count
of actions performed

df = df.append({'Benefit_Group': group,
'Status': status, 'Count': count,
'Start_Time': start_time,
'End_Time': datetime.datetime.now()},
ignore_index=True)

# Generate Excel report

df.to_excel('Benefit_Groups_Report.xlsx',
index=False)

# Execute the process

process_benefit_groups()

https://iaeme.com/Home/journal/IJCET 72 editor@iaeme.com
 Jayesh Jhurani

Benefits of using Python and Selenium

Automating tasks within complex web applications like Workday using Python and Selenium
involves navigating through various challenges, especially when dealing with dynamic content
and user interactions. The Jupyter Python script that automates the closure and finalization of
benefit groups while addressing specific challenges such as date selection, scrolling to load
more rows, error detection, and background clicking, showcases the depth of consideration
given to the automation process. Here's an elaboration on how each of these challenges is
resolved:

Ability to Select a Date

● Challenge: Automating date selection in web forms can be tricky due to the variety of
date picker implementations, including calendar widgets or dropdown menus.
● Solution: The script uses Selenium to interact with the date picker element, either by
sending keystrokes that represent the date directly to the input field or by navigating
through the calendar widget to select the correct date. This approach requires identifying
the specific HTML elements involved in date selection and using Selenium’s methods
to interact with them effectively.

Ability to Scroll and Load More Rows

● Challenge: Web applications often load data dynamically as the user scrolls down the
page, known as infinite scrolling. This can pose a challenge for automation scripts that
need to interact with elements not yet loaded on the page.
● Solution: The script can simulate scrolling actions using Selenium’s JavaScript
execution capabilities (execute_script) to trigger the loading of additional rows. This
may involve scrolling to the bottom of the page or a specific element until all required
data is loaded and accessible for automation.

Ability to Detect Workday Error

● Challenge: Handling errors or pop-ups that may occur during the automation process,
such as validation errors or system messages, is crucial to ensure the script can proceed
without manual intervention.
● Solution: The script includes error detection logic by periodically checking for the
presence of known error message selectors or dialog boxes. Upon detecting an error, the
script can log the issue, take corrective action, or retry the operation, depending on the
error type and the desired workflow.

Ability to Click in the Background

● Challenge: Some automation tasks may require interacting with elements that are not
in the foreground or are obscured by other elements, making direct clicks challenging.
● Solution: The script can use advanced Selenium techniques to interact with such
elements. This might involve directly sending a click command to the element via
JavaScript (execute_script) or adjusting the page’s scroll position to bring the element
into view before clicking. In some cases, actions like moving to an element with the
keyboard before performing the click can also be effective.

https://iaeme.com/Home/journal/IJCET 73 editor@iaeme.com
 Automation In Workday Using Python-Selenium

Overall Strategy and Benefits

By addressing these challenges, the automation script enhances the robustness and reliability
of the process for closing and finalizing benefit groups in Workday. This not only ensures that
the automation can run smoothly without manual intervention but also improves the overall
efficiency and accuracy of the task. The capability to handle date selection, dynamic content
loading, error detection, and background interactions makes the script versatile and adaptable
to various scenarios within the Workday environment.

Implementation and Continuous Improvement

● Testing and Validation: Rigorous testing is essential to validate the script’s
effectiveness in handling these challenges under different conditions and to ensure it
can recover gracefully from errors.
● Maintenance and Updates: Keeping the script updated to reflect changes in
Workday’s UI or functionality is crucial for its long-term viability. Regular reviews and
updates help maintain its efficiency and effectiveness.
● Scalability: As new requirements or challenges emerge, the script can be further refined
or expanded, leveraging the flexibility and power of Python and Selenium.
This detailed approach to overcoming specific automation challenges in Workday not only
showcases the technical capabilities of Python and Selenium but also highlights the strategic
thinking behind automating complex HR processes, ultimately leading to significant time
savings and operational improvements.

CONCLUSION
In conclusion, the research paper demonstrates the effectiveness of automating Workday's
benefits management process using Python and Selenium. This approach addresses significant
challenges such as manual process inefficiencies, error-proneness, and the labor-intensive daily
closure and finalization of multiple benefit groups. By implementing a Python script to
automate these tasks, organizations can achieve considerable time savings, enhance accuracy,
improve the employee experience, and ensure up-to-date benefits administration. The solution
leverages open-source technologies to provide a cost-effective alternative to commercial RPA
tools, offering customization and flexibility while maintaining security and compliance. This
strategic automation initiative showcases the potential to streamline HR operations
significantly, promoting operational improvements and strategic HR management.

REFERENCES
[1] “Predictive HR Analytics: Mastering the HR Metric” by Dr Martin Edwards, Kirsten
Edwards

[2] "Python for Data Analysis" by Wes McKinney.

[3] "Using Python for API Integration" by Nitin Padalia on Medium.

[4] "Integrating Cloud ERP Systems with External Applications: A Guide" by Open Mind
Solutions.

[5] "A Beginner's Guide to API Integration" by Rapid API.

https://iaeme.com/Home/journal/IJCET 74 editor@iaeme.com
 Jayesh Jhurani

[6] https://pandas.pydata.org/

[7] https://www.python.org/

[8] https://pypi.org/project/requests/

[9] https://community.workday.com/

[10] "Test Automation using Selenium WebDriver with Java" by Navneesh Garg

https://iaeme.com/Home/journal/IJCET 75 editor@iaeme.com