Hello There, I'mKitt Parker

Why Every Developer Needs Version Control

• Git
• June 12, 2025
• 6 min

Version control is more than just a backup tool—it's the backbone of professional software development. Tools like Git help developers track changes, collaborate with teammates, and recover from mistakes without losing valuable work. Yet, many teams still skip it, leading to lost code, overwrites, and unnecessary stress.

One of the biggest misconceptions surrounding Git is that it’s owned by Microsoft because GitHub—one of the most popular hosting platforms—is a Microsoft product. In truth, Git is a free and open-source tool created by Linus Torvalds, and you can host it yourself without relying on any third-party service. Platforms like GitLab, Gitea, or even a bare server over SSH allow teams full control over their repositories.

Without version control, even minor changes become risky. There’s no audit trail, no way to revert a buggy update, and no insight into who changed what, when, or why. Teams working without Git often resort to naming files like homepage-final-FINAL-v3-last-update.html, which is as unsustainable as it sounds.

Git enables branching—isolating features or fixes without touching production code. It supports pull requests, structured reviews, and CI/CD pipelines. It brings transparency, accountability, and confidence to your development process.

Whether you're a solo developer or managing a large team, using Git is non-negotiable. It's not just a safety net—it’s a framework for delivering better, cleaner, and more collaborative code. And no, you don’t need GitHub to benefit. You can run Git entirely on your own terms.

The Power of Custom Apps: Real-World Wins

• Applications
• June 12, 2025
• 6 min

Off-the-shelf software works—until it doesn’t. Many businesses reach a point where general-purpose tools no longer support their workflows or scale with their growth. That’s when custom applications—whether web-based or desktop—step in to deliver tailored performance.

A real-world example: a field service company was using spreadsheets and manual email tracking to assign technicians. Errors were frequent, and scheduling delays were routine. A custom web app was built to integrate with their job intake, technician availability, and SMS alerts. Within weeks of rollout, dispatch times dropped by 60%, and complaints from missed appointments all but vanished.

For desktop environments, a logistics firm struggled with outdated Windows applications. A custom .NET desktop app replaced three separate legacy systems and synced with their ERP. Now, drivers receive optimized routes automatically, and billing staff get real-time updates.

Custom apps aren’t just about solving problems—they're about creating strategic advantage. You get exactly what your workflow demands, with the flexibility to iterate over time. And because the system is built around your process—not the other way around—training is faster, errors drop, and users stay engaged.

The Benefits—and Challenges—of Embracing Automation

• Automation
• June 12, 2025
• 6 min

Automation has rapidly become a cornerstone of modern IT and business operations. From reducing manual errors to accelerating workflows, automation brings undeniable efficiency and consistency to any organization. Whether you’re automating a deployment process or a routine report, the payoff is tangible—and often immediate.

Tools like Python allow for flexible scripting across platforms, while AutoIT excels in Windows GUI automation. On the enterprise level, platforms like UiPath enable full-scale Robotic Process Automation (RPA) with low-code interfaces that empower both developers and business users.

But automation isn’t always plug-and-play. One major obstacle is **process clarity**—you can’t automate what you don’t fully understand. Teams often rush to automate inefficient or unstable workflows, which only makes problems faster and harder to debug. There’s also a learning curve in choosing the right tool for the right task, and maintaining automation scripts requires its own discipline.

Another challenge is **integration**. Connecting automation scripts to legacy systems, cloud APIs, or ERP platforms like Acumatica can be time-consuming. Security is also a concern—especially with credential handling and unattended access. These issues need to be addressed up front for automation to be sustainable.

Despite these hurdles, the long-term benefits of automation are hard to ignore. By removing repetitive work, teams can focus on strategic efforts. With robust tools like Python, AutoIT, and UiPath in your toolkit, automation becomes more than just a buzzword—it becomes a competitive advantage.

Should Technical Managers Be Technical?

• Leadership
• June 12, 2025
• 7 min

There’s an ongoing debate in tech leadership: should managers of technical teams be technical themselves? While not every manager needs to write production-ready code, a solid technical foundation can mean the difference between diffusing a problem—and pouring gas on it.

Consider this real-world example: a Git conflict on a Windows development machine. One junior engineer renamed a file from LoginPage.js to loginpage.js. On a Linux-based Git repository, this would result in two distinct files. But Windows is case-insensitive, meaning Git treated it as the same file. The rename resulted in Git interpreting the change as a deletion and re-addition—which under certain conditions caused Git to delete the file entirely.

Now imagine two engineers arguing over who "deleted" the file. Without a technical understanding of Git internals and OS-level filesystem behavior, a manager might resort to vague conflict resolution rather than diagnosing the actual cause. In this case, the root issue isn’t intent—it’s platform behavior and Git’s limitations on Windows.

Git itself was developed on Linux, where file paths are case-sensitive. On Windows, however, this discrepancy introduces subtle bugs that only a technical person might catch. A manager without that knowledge may not realize this is a systemic limitation—not a personnel problem.

Good managers shield their teams from noise, guide decisions, and solve problems. But technical managers bring an added layer of insight that helps them understand tradeoffs, prevent escalations, and contribute meaningfully in architectural discussions. They don't need to code daily—but they need to speak the language.

In short: technical teams thrive when their leaders understand the terrain. Without that understanding, even simple bugs can escalate into unnecessary blame games—and that costs far more than a lost file.