Build or Buy Workforce Management Software? Inside Binariks' Custom Approach

Let's be honest – it seems like keeping track of time, payroll, and approvals shouldn't be that hard, especially for a company dealing with way more critical and fundamental tasks for its clients as a casual routine.

Yet the more you grow, the more complicated workforce management gets. We're talking scattered spreadsheets, clunky SaaS tools, endless manual approvals, and workflows that feel like they belong in the last decade.

At first, we did what most companies do. We bought tools. Several of them. Each promising automation, analytics, and seamless integrations. But instead of simplifying things, we ended up with:

• Too many disconnected platforms – HR, finance, and department heads all had their own tools that didn't talk to each other.
• Customization roadblocks – Want a simple process change? That's an expensive add-on.
• Data silos everywhere – Payroll, compliance, and workforce planning were a guessing game.
• Hidden costs creeping up – By the time we unlocked the features we really needed, we were paying more than we ever planned.

And time tracking? What seemed like a simple task turned into a logistical nightmare. Custom approvals? Pay extra. Internal tool integrations? Another upgrade. Better reporting? Only if you're on the enterprise plan, which generally costs twice as much as the standard one at best. Before we knew it, we were overpaying for tools that didn't actually work for us.

So one day, we decided: We're out. It's time to stop trying to make rigid tools fit our workflows. Yes, we've faced the same challenges as everyone else, but after all, with strong tech expertise, we had the ability to solve them head-on, right here, right now.

Now, we want to share our journey – how we tackled these challenges, what we learned along the way, and, of course, how our approach might help you, too.

When workforce management fails, everyone feels it

You don't need to be in HR to feel when your workforce management system isn't working. The ripple effect is real – from frustrated recruiters and overwhelmed accountants to confused project leads and employees constantly double-checking their hours.

We've felt it, too.

Before we even thought about building a new tool, we started where it hurts – listening. We talked to every team involved in workforce operations and asked questions:

What slows you down? What drives you crazy? What's wasting your time?

Not once. Not in a single meeting. But over weeks of collecting feedback, examples, complaints, and wishlist items from across the company.

Why?

Because we weren't just replacing a tool. We were designing a system that would fit real people and not force them to adapt to some off-the-shelf logic. And when you get that part right – the process, the conversations, the actual pain behind the workflows – you end up with something more valuable than just a solution for your particular company. You build a reusable blueprint that could potentially benefit any team struggling with the same mess.

Here's what came up again and again across departments:

Common pain points (yes, still very real):

• Fragmented data: Everyone was working in silos. HR had one system, finance another. Nobody could see the full picture.
• Manual workflows: Time-off approvals in emails, payroll in spreadsheets… and too much room for error.
• No centralized reporting: Leaders lacked visibility. People guessed instead of clearly seeing.
• One-size-fits-none SaaS tools: We were paying for some features we didn't use but missing the ones we actually needed.

The deeper we went, the more it became clear:

To solve this, we had to design around people – not licenses, not vendors, not "what's trending."

That feedback process was the first real step in our strategy. In the next chapters, we'll break down how it turned into a full-fledged solution.

How we think before we build

Step 1: Turning everyone's feedback into a game plan

Once we started collecting insights across teams, patterns quickly emerged. Everyone had their own set of headaches – some visible, others buried in spreadsheets and Slack or Google chat threads. So, instead of jumping into coding right away, we mapped out the needs of each group and used that as our foundation.

Here's how this shaped our plan:

Step 2: Build a bit, learn a lot, repeat

We knew this couldn't be a one-and-done kind of build. So we took it in phases – small releases, constant feedback, fast iterations.

We kicked things off by looking at how our existing tools were actually being used (or, let's be honest, ignored). We mapped out what was slowing us down, where data was falling through the cracks, and which tasks could be handed off to automation. It gave us the clarity we needed to move with confidence.

Step 3: Two tools, one ecosystem

What we ended up with was a system built around two tightly connected apps – one for managers and one for employees. Each had its own role, but everything flowed together.

• The Admin Tool to help managers and accountants stay on top of reporting, workforce allocation, and approvals.
• The Time Tracker Tool to give employees a super simple way to log hours, request time off, and track B-Coins.

We didn't stop at functionality – we layered in smart automation to eliminate all the repetitive stuff. Here's how it breaks down:

Here is how we structured these tools' features:

By structuring the system in this way, we wanted to ensure that:

• It gives every team a shared source of truth
• It makes employee tasks (and rewards) easy and transparent
• It cuts down time spent on manual processes across departments

But most importantly, having this vision gives us a solid base that can grow with the company. Moreover, it could even be adapted to fit entirely different teams or industries down the line.

Making it real: From system sketches to a working, scalable tool

Once we nailed down what the workforce management solution should do, it was time to make sure it actually works – reliably, securely, and without breaking the bank. Here's a look under the hood at the technical choices that made this possible.

1. Secure data handling: Dividing a monolith into two APIs

One of our top priorities was protecting sensitive data. We needed to ensure that confidential data was inaccessible to the development team while allowing access to general information for monitoring and debugging in production.

What we did:

• Created a separate database for storing confidential data.
• Split the main API into two:
• General API: Handles non-confidential general data.
• Confidential API: Operates exclusively with sensitive information.

This architecture isolates critical data, creating a clean boundary and helping minimize risk while supporting secure, flexible maintenance.

2. Cost-conscious deployment: One EC2 instance, two APIs

After splitting the monolith, we needed to determine the most cost-effective hosting solution without compromising performance.

What we did:

• Instead of separate EC2 instances, we hosted both APIs on one EC2 instance, using nginx to route requests based on URLs.
• Configured APIs to use different ports to prevent conflicts after deployment.
• Packaged both APIs as separate build artifacts and deployed them together.

This approach significantly reduced infrastructure costs while maintaining system reliability.

3. Google services integration: Security and onboarding, streamlined

Since most of our operations already live in Google, we leaned into that ecosystem for better automation and tighter security.

So first, we created a service account in Google AdminSDK, using AWS Secrets Manager to store credentials securely.

Google Directory API – Security checks on every request:

• Problem: If an employee's account would be hacked, the attacker could still access the system during the JWT token's lifetime – even after the account was blocked.
• Fix: We now check user status via the Google Directory API on every request. If their account is blocked, access is denied. No delays, no gaps.

Automating employee onboarding

• We used the Google Directory API to automate work account creation.
• Once a recruiter enters a new employee's details into our system, the administrator can create a work account with a single click – no manual entry, as it's pulled from the database.

4. Connecting to the System Admin tool: Resignation letters that don't miss a thing

Resignation letters were needed to list company-owned assets, but that info was in a separate System Administration (SA) tool that has its own API and is not in our database.

So we built a bridge.

How we did it:

• The SA tool's API was identified and used to retrieve asset data.
• API requests were authorized using the API key stored in AWS Secrets Manager.
• Before generating a resignation letter, an HTTP request must be sent to the SA tool to fetch assigned assets.

However, there was an additional challenge: we needed the employee's ID in the SA system. To resolve this, we further automated employee creation across the company's infrastructure:

• When a Google work account is created for a new employee, a corresponding user is automatically generated in the SA tool.
• The employee's SA system ID was then stored in our database for future reference.

Now, employee creation has become an automated process, and when someone leaves, we know exactly what gear they have – no guesswork, no digging through spreadsheets.

5. Vacation logic that actually reflects real-life company policies

Managing time off isn't just about counting days. Our system had to reflect overlapping accrual periods, probation rules, and custom policies.

Our solution:

• We introduced a VacationPeriod entity that tracks:
• Accumulation period (one year)
• Usage period (additional six months)
• Expiration rules

• When an employee accesses the Vacation page, the system makes a real-time request to the backend to ensure up-to-date calculations.

Handling complex scenarios:

• Employees can have two active vacation periods during the six-month overlap.
• Employees can be eligible for vacation period extensions under certain extreme conditions or edge cases.
• Probation period restrictions prevent early vacation logging.

The result? A vacation system that reflects reality, not just theory – and keeps HR from chasing people down over misused days off.

Lessons from the build: Balancing needs, tech, and reality

No complex system gets built without hitting a few walls – and ours was no exception. In fact, the hurdles we faced helped refine our thinking and sharpen the solution. Here's what pushed us and how we pushed back:

Adapting to evolving company processes

The company's internal processes weren't static – they evolved frequently as new needs and workflows emerged.

That meant our system couldn't be a one-and-done product. It had to be flexible, modular, and constantly adaptable. We kept development cycles ongoing to make sure the platform stayed in sync with how the business actually operated.

Handling stakeholder feedback (without losing focus)

People across departments had opinions – and they weren't always aligned. HR had one view, finance another, and managers something else entirely. On top of that, they all had day jobs. So, we had to be proactive:

We gathered input in digestible ways, zeroing in on the most critical issues.

We focused on onboarding and change management, helping users understand and adopt new features quickly and with minimal friction.

Balancing cost, security, and compliance

This was a constant balancing act. We had to build something secure enough for enterprise needs, compliant with ISO standards, and still cost-effective. Key areas we had to address:

• Data confidentiality, especially in handling sensitive documents
• Access control management, ensuring proper role-based permissions
• System reliability, minimizing downtime to prevent delays in payroll processing and invoicing
• Compliance with ISO standards, requiring adherence to security best practices such as OWASP checklists and structured audit requirements

Managing edge cases and managerial flexibility

Even the best-designed rules don't cover 100% of real-world scenarios. We knew edge cases would pop up – unexpected transitions, exceptions, and time-sensitive decisions. So, we designed a system that's both smart and human:

• We designed the UI to allow managers to override certain restrictions when critical needs arose.
• This provided upper management and C-level executives with flexibility, ensuring the system supported, rather than hindered, business operations.

At the end of the day, we prefer to look at all this not as just "challenges" but as learning curves that helped us engineer a stronger product and a smarter process.

The result is a workforce management system that's more than just secure and compliant – it's future-ready and flexible enough to grow with the business.

Could this work for your company? Let's find out!

After all the work done, we were once again convinced that workforce management isn't just about having "a tool." It's about whether your systems actually support your team – or quietly slow them down.

We didn't build a solution because we love reinventing the wheel. We did it because nothing out there fits how we truly work. Off-the-shelf tools made us change our processes to fit their logic. That led to scattered data, workarounds, unnecessary SaaS costs, and wasted time across departments.

Of course, there are still plenty of solid off-the-shelf solutions out there, and we have no intention to demonize them as a category. They work great for many companies. Yet, if you're a mid-sized, rapidly scaling company, constantly adapting to new processes, or finding yourself hitting customization roadblocks with existing software – that's when a custom solution can really shine. Especially if you want to leverage flexible tools like ours as a solid base and then have them tailored to slot perfectly into your workflows.

Because one of the biggest wins with our system is how it's grown step-by-step with our evolving needs, reflecting the dynamic nature of a growing business.

And now, everything flows from one central place – with less friction, fewer errors, and way more visibility.

And here's what changed:

Why does this matter? Because it's not just an admin win. It's a business win. We cut down on approval delays, minimized manual errors, reduced overhead, and gave every team – from HR to finance to C-level – a clearer view of what's really happening.

And here's the thing: this system was built for us, but the process and experience behind it? That's repeatable.

If workforce inefficiencies are slowing you down, let's talk . A tailored solution might be closer (and more affordable) than you think.