Author: Abe

Lessons Learned from an Application Migration

I didn’t fully appreciate how many “small details” can turn into big operational problems until we migrated from one system to another.

When organizations start shopping for a new application, it’s easy to get swept up in the excitement of demos. Everything looks polished. Every platform seems to promise efficiency, better reporting, and a smoother experience. But over time I’ve learned that picking the right system has less to do with flashy features and more to do with discipline: knowing what you truly need, understanding what you can compromise on, and refusing to confuse “nice-to-have” with “must-have.”

The first step isn’t comparing vendors—it’s looking inward. Before considering a move, the organization has to clearly list what’s wrong with the current system and decide what is actually business-critical versus what is just annoying. That matters, because migrating is expensive. Licensing is only one part of the cost. You pay for implementation, training, staff time, productivity loss, and the hidden labor that shows up when people create workarounds. If you don’t define your reasons up front, you’re not selecting a solution—you’re just switching problems.

Once you have the real needs documented, demos become more meaningful. Instead of letting vendors guide the conversation toward shiny extras, you drive the demo toward your workflows. You test the things that matter most: the core functions your teams depend on every day, the scenarios that cause pain today, and the edge cases that will quietly break things later if no one looks closely.

That’s where one of our real lessons came in.

During our transition from UKG Ready to Paylocity, we ran into an unexpected challenge around holiday handling. On the surface it sounds simple: a holiday is a holiday. But in practice, the difference between “holiday time off” and “holiday worked” matters—especially in environments with varied staffing patterns. UKG handled that distinction more clearly, while Paylocity approached holidays more simply. The result wasn’t just a preference issue; it became a workflow issue. And the honest truth is this: if we had specifically tested that scenario during evaluation, it wouldn’t have been a surprise after go-live.

That’s why I believe the most important part of application selection is this: involve all departments early, not just the one pushing for the change. Many systems are multi-department by nature, and decisions shouldn’t be made in silos. Each department understands its own workflow best, and those workflows often connect in ways people don’t notice until something breaks.

A good example is scheduling inside a timekeeping system. Some people view scheduling as a minor module—something “nice” to have. But scheduling affects staffing coverage, reveals hiring needs, exposes gaps, and shapes daily operations. What looks like a small feature in a demo can directly impact labor planning and service continuity. When an application is selected without understanding those dependencies, the system may work for one team while creating friction for another.

In that process, IT plays a role that goes far beyond security—even though security is non-negotiable. Yes, IT has to evaluate user management, roles and permissions, data protection, compliance requirements like HIPAA, and vendor assurances such as SOC reports. But IT also has to act as the connective tissue across the organization. Departments often evaluate tools based on their own isolated use cases. IT helps ensure the platform supports end-to-end workflows across departments and that the organization isn’t accidentally adopting a system that only works when everyone stays in their own lane.

The other lesson that becomes clearer with every major change is that planning isn’t optional. You need enough time to document issues, define requirements, shortlist vendors, run demos that reflect real workflows, and confirm the new system solves actual problems without breaking core functions. And you need time not just to select, but to implement properly—because implementation is where most “good decisions” either succeed or collapse.

Even outside of migrations, workflow documentation is underrated. Every department should document how work gets done—not only for continuity when staff changes, but because those documents become the foundation for evaluating any new system. And from an IT governance standpoint, it helps to maintain an application inventory: what systems you have, who depends on them, and when they reach end-of-sale, end-of-service, or end-of-life. That kind of visibility prevents rushed decisions and last-minute disruptions.

In the end, successful application migration isn’t really a technology project. It’s an organizational discipline. It’s planning, documentation, collaboration, compliance awareness, and strong governance—designed to protect continuity while the tools change around you.

Because the truth is: switching systems is not easy. Switching systems well is the real work.

Python Math Game

This is a program I made for my daughter to sharpen her multiplication skills. This program is a multiplication quiz game that asks the player 10 random multiplication questions. The game tracks the number of correct and incorrect answers, records how long the player takes to answer each question, and saves the results in a text file called multiplication_results.txt.

She enjoys playing with this program even if it is just a plain text game. Below is the source code of version 1. If you want a copy of the program leave a comment below. Stay tuned for the next version, which is coming soon!

Read more

Updating Active Directory User Data

The Situation

Adding new employee user accounts, updating their information when changes occur, and deleting accounts when employment ends are straightforward tasks in Windows Active Directory—if you’re only managing a small number of changes at a time.

However, this simplicity becomes a challenge as the number of employees grows, as we’ve experienced at work. Over the years, our employee count has increased, leading to a corresponding rise in domain users. Additionally, every employee requires access to a domain computer to perform their work. On top of that, we also need to create user accounts for interns, volunteers, and contractors, and managing their access status further complicates things.

To make matters worse, we have a limited number of IT staff and a restricted IT budget, as our organization is a non-profit. Therefore, I need to find a solution to manage this aspect of our work more efficiently.

Here’s What I Did in This Situation

I recognized that finding better ways to manage our user list was a significant project for us, but I was confident that once completed, it would bring substantial long-term benefits to the department. The first step I took was to examine our HRIS (Human Resources Information System) and AD (Active Directory), comparing the information in AD with what we had in our HRIS.

One issue I noticed was that the employee ID number had never been entered into AD. I understood that this would be the first thing I needed to address. I needed a unique key for this project, and the EIDN (employee ID number) served this purpose perfectly.

To begin, I created a local folder on my computer and prepared a CSV file with the following columns:

  • SamAccountName
  • EmployeeID
  • Department
  • ManagerSamAccountName

Next, I wrote a PowerShell script to generate a CSV file in this format. I also created a corresponding report in our HRIS with the following columns:

  • Username
  • EmployeeID
  • Department
  • Manager
Get-ADUser -Filter {Enabled -eq $true} -Properties EmployeeID, Department, Manager |
Select-Object Name,SamAccountName,EmployeeID,Department,Manager |
Sort-Object Name |
Export-Csv -Path "C:\psLogs\EmployeeList-AD-result.csv" -NoTypeInformation

Using MS Excel, I populated the CSV file with the necessary information. I used the VLOOKUP function in this task.

Then I created this script that will import the CSV file and update the Active Directory.


Import-Csv -Path "C:\psLogs\EmployeeList-AD.csv" |
ForEach-Object {
$managerDN = (Get-ADUser -Identity $_.ManagerSamAccountName).DistinguishedName
Set-ADUser -Identity $_.SamAccountName -EmployeeID $_.EmployeeID -Department $_.Department -Manager $managerDN

}
<h1>Use this if you want to export results into a csv file.</h1>
Get-ADUser -Filter {Enabled -eq $true} -Properties EmployeeID, Department, Manager |
Select-Object Name,SamAccountName,EmployeeID,Department,Manager |
Sort-Object Name |
Export-Csv -Path "C:\psLogs\EmployeeList-AD-result.csv" -NoTypeInformation

Now that I have the EID of employees I can easily compare our current employee list with our active AD user list.

Life of an IT Professional.

I have been in the IT profession for a long time. This series of posts covers various scenarios I’ve encountered and how I tackled each one. It’s not intended to prescribe how things should be done, but rather to serve as a personal journal of my IT work. Also, I’m grateful for the internet and the many people who generously share their knowledge. That’s why I’m creating this series—to give back to the community by sharing my life experiences as an IT professional.

If you stumble upon our website and have questions about my posts, feel free to leave a comment below.

Custard Dessert

Our family loves custard-filled pastries like cream puffs, custard-filled donuts, and eclairs. My wife shared her egg custard pie recipe back in 2013. To satisfy the craving we usually go to nearby Krispy Kreme and buy their chocolate iced custard-filled donuts.

Ingredients

3 egg yolks
45 grams of sugar or 5 1/2 packets of Truvia
10 grams of cornstarch
300 mL of whole milk
5ml of vanilla extract
1 pinch of salt

Procedure

SonicWall NSM Reporting Issue

Yesterday, I logged in to our SonicWall NSM and noticed that reports did not have data for a few days. I get an error when I generate the report in Reports / Rules. I go to Firewall / Inventory and go to our NSA 2700, and noticed that when you go to Monitor/ Overview / Live Monitor, there is no data.

Below are the steps I took to resolve the issue.

  • In Firewall View, Go to Device / AppFlow / Flow Reporting to check your settings. Checked Statistics, and made sure your connection flows and data flows. Check your Settings that it is still set to send the report.
  • Go to Device / Settings / Licenses and just check that your license did not expire.
  • Go to Device / Settings / Firmware and Settings and check the firmware version. This will be a good time to check if your cloud backup is working and download a local backup.

At the time, all looks good, except that the firmware is one release behind. I called support just to confirm that there is no current issue with NSM, and it was confirmed that there is no ongoing service issue. Support checked settings and suggested to update to the latest firmware.

  • I logged in to MySonicWall and downloaded the latest release. I logged in to our NSA 2700 locally and installed the firmware. The update took about 20 to 25 minutes since we have HA setup. Firmware was installed on Secondary, failed over to Secondary then it was installed on Primary. After the Primary installation was completed, I failed over back to Primary.
  • I went back to NSM and clicked on Synchronize Firewall as it is showing up as unmanaged.
  • I then clicked on Reconfigure Reporting & Analytics to make sure the reporting was synching.

The update process was smooth, and we experienced no significant disruptions during the transition to the latest firmware. 10 minutes, I revisited Firewall View / Monitor / Overview / Live Monitor on our SonicWall NSM, and I now see data/ information showing up.

Arduino and the SD Cards

As I delved deeper into my Arduino journey, I soon recognized the importance of collecting and storing data. This realization came after I had gained proficiency in working with various components, including piezo buzzers, vibrant LEDs, precise digital temperature and humidity sensors, real-time clocks (RTC), and the 16×2 LCD display. With these tools at my disposal, I was able to embark on a fascinating project – a clock that not only kept time but also displayed real-time humidity and temperature readings. This project marked a significant milestone in my Arduino learning adventure, showcasing the practical applications of my newfound skills.

Read more: Arduino and the SD Cards

List of Materials

  • Arduino Uno R3
  • Lexar 32GB Micro SD Card, microSDHC UHS-I Flash Memory Card

References

Notes

Arduino and the RTC (Real Time Clock)

After learning how to use a 16 x 2 LCD Display with Arduino to show data, I was inspired to create a digital clock using use a 16 x 2 LCD Display to display date and time. However, I discovered that Arduino lacks a built-in clock. To address this, I learned that an RTC (Real-Time Clock) is necessary to work with date and time information.

Read more: Arduino and the RTC (Real Time Clock)

On this project, I used a DS3231 Real Time Clock Module.

On the DS3231 Real Time Clock Module, I connected the red cable to VCC, then connected the black cable to the ground pin. I connected the orange cable to SCL pin, then connected the yellow cable to SDA pin.

This is how it looks how I connected the DS3231 Real Time Clock Module to Arduino Uno.

This is what the serial monitor will look like after the sketch is uploaded to the Arduino Uno.

Connect your Arduino to your computer and upload the sketch. Below is the sketch to upload to your Arduino.

#include <Wire.h>
#include <DS3231.h>

DS3231 Clock;
RTClib RTC;

void setup() {
  // put your setup code here, to run once:
  Wire.begin();
  Serial.begin(9600);

  Clock.setYear(23);
  Clock.setMonth(10);
  Clock.setDate(9);
  Clock.setDoW(1);
  Clock.setHour(0);
  Clock.setMinute(10);
  Clock.setSecond(50);
  Clock.setClockMode(0);
  }

void loop() {
  // put your main code here, to run repeatedly:
  DateTime Time = RTC.now();

  Serial.print(Time.year(), DEC);
  Serial.print("/");
  Serial.print(Time.month(), DEC);
  Serial.print("/");
  Serial.print(Time.day(), DEC);
  Serial.print(" ");
  Serial.print(Time.hour(), DEC);
  Serial.print(":");
  Serial.print(Time.minute(), DEC);
  Serial.print(":");
  Serial.print(Time.second(), DEC);
  Serial.println();

  delay(1000);
}

List of Materials

  • Arduino Uno R3
  • DS3231 AT24C32 Real Time Clock Module
  • Male-to-female breadboard jumper ribbon cables

References

Notes