Peopleware MX
Full-stack engineering across enterprise multi-tenant payroll, HR, attendance management, reporting, and business integration systems.
Overview
At Peopleware MX, I worked as a full-stack engineer on enterprise business systems used by HR and payroll departments across multiple client organizations. The platform handled multi-tenant payroll processing, attendance management, business reporting, and integrations with third-party systems.
The work involved .NET backend APIs, SQL Server data modeling and optimization, Entity Framework with LINQ, and Vue 2 frontend interfaces. Engineering decisions were shaped by business-critical requirements — correctness, performance, and multi-tenant data isolation were non-negotiable.
Engineering Scope
Core Enterprise Platform
Multi-tenant payroll, HR, and attendance management systems serving enterprise client organizations. Business-critical logic with strict correctness requirements around pay calculations and employee records.
Backend APIs & Data Layer
.NET Web API endpoints, SQL Server schema design, Entity Framework queries, LINQ operations, and stored procedures for complex reporting and business workflow logic.
Reporting & Business Workflows
Performance-sensitive reporting queries, business rule engines, and workflow automation. Reporting workloads required SQL optimization to remain usable at enterprise data volumes.
Frontend Enterprise Interfaces
Vue 2 internal business interfaces for HR administrators, payroll operators, and attendance coordinators. Role-based access control and CASL authorization integrated at both API and UI layers.
Enterprise Integrations
External business systems the platform had to interoperate with — biometric attendance hardware using proprietary protocols, and spreadsheet-based reporting tools that clients actively relied on. Data consistency and synchronization reliability were ongoing engineering constraints, not one-time integration problems.
Representative Engineering Initiatives
Multi-Tenant Payroll & HR Platform
Context
Enterprise clients each had distinct payroll rules, deduction structures, attendance policies, and compliance requirements. Encoding these as rigid logic per client was not sustainable — the platform needed to accommodate business-rule variation without forking the codebase.
Work
Built and maintained configurable backend logic with per-tenant rule sets covering payroll calculations, attendance policies, and HR record validation. Maintained tenant data isolation across shared infrastructure while keeping the core platform stable across client-specific configurations.
Business rule modeling · Multi-tenant isolation · Configurable backend architecture
SQL Optimization & Reporting Infrastructure
Context
Reporting against large enterprise datasets was slow enough to make the features effectively unusable in production. The bottlenecks were spread across stored procedures, ORM-generated queries, and missing indexing — not a single root cause.
Work
Rewrote critical reporting queries as optimized stored procedures, identified Entity Framework patterns causing N+1 and over-fetching, applied targeted indexing based on query plan analysis, and tuned LINQ operations on large datasets. Optimization decisions were driven by real production latency, not benchmarks.
Stored procedure design · ORM query optimization · Production query analysis
Enterprise Systems Integration
Context
The platform needed to synchronize with systems that operated independently and had no designed integration point — biometric attendance hardware using proprietary protocols, and spreadsheet-based reporting workflows that clients were unwilling to abandon.
Work
Designed synchronization pipelines and intermediary services to bridge disconnected systems into the platform's data layer. The engineering challenge was reliability and normalization: hardware event logs had gaps, duplicates, and vendor-specific formats that needed to produce clean attendance records.
Integration architecture · Data normalization · Cross-system synchronization
Client Onboarding & Workflow Translation
Context
Enterprise clients came with existing payroll and HR workflows that had been refined over years of operational use. Translating those into platform-compatible configuration required understanding both the business domain and the system's flexibility boundaries.
Work
Participated in onboarding sessions with enterprise clients — mapping existing workflows to system configuration, clarifying technical constraints during requirement discussions, and identifying gaps between what clients expected and what the platform could support. Surfaced these gaps early to avoid late-stage rework.
Business domain modeling · Technical requirement clarification · Workflow mapping
Technical Challenges & Solutions
Configuring business rules across tenant boundaries
Problem
Payroll, attendance, and HR rules varied significantly between clients — deduction structures, overtime policies, pay period definitions. A single rigid model would require per-client workarounds that compounded over time.
Solution
Modeled the variable behavior as configurable rule sets applied at runtime per tenant, isolating the core calculation engine from client-specific parameters. This kept the platform maintainable as the client base grew without requiring separate deployment paths.
Reporting performance at enterprise data volumes
Problem
Reporting queries became increasingly slow as client datasets grew. The latency had direct business impact — reports that took minutes were blocking HR and payroll workflows.
Solution
Profiled slow queries using execution plans rather than guessing. Rewrote the worst offenders as stored procedures, eliminated ORM-generated N+1 patterns, and applied indexing where the query planner showed full scans. Prioritized the queries with the highest usage and worst execution time first.
Synchronizing proprietary biometric hardware
Problem
ZKTeco attendance devices used proprietary protocols and produced raw event logs with inconsistent delivery — missing records, duplicates, and vendor-specific formats that didn't map cleanly to the platform's attendance model.
Solution
Designed a synchronization strategy that treated device output as inherently unreliable: normalize formats, discard duplicates, and handle connectivity gaps without data loss. The priority was trustworthy attendance records, not just a pipeline that transferred data.
Replacing manual spreadsheet exports
Problem
Clients depended on Google Sheets for reporting but relied on manual CSV exports from the platform. Data was frequently stale, versions drifted, and the manual steps created friction that compounded across clients.
Solution
Connected the platform API directly into clients' existing spreadsheet workflows so reports could be refreshed on demand. The design constraint was that clients weren't going to change their tools — the integration had to meet them where they already worked.
Technologies & Systems
Engineering Growth
- Built intuition around multi-tenant system design — where shared infrastructure creates leverage, and where tenant-specific variation needs explicit isolation rather than workarounds that accumulate over time.
- Learned where ORM abstractions break down in practice: Entity Framework works well until it doesn't, and production reporting bottlenecks taught better judgment about when to drop to raw SQL, when to optimize query shape, and when the schema itself is the problem.
- Working across hardware integrations, spreadsheet tools, and internal APIs made it clear that reliability can't be assumed from external systems. The engineering judgment is in how you handle the cases where the other side behaves unexpectedly — not just the happy path.
- Gained real understanding of business domain complexity: payroll and HR rules look simple until you model them across clients with different policies, compliance requirements, and historical edge cases baked into their workflows.
- Learned what production ownership means in enterprise software — when payroll runs wrong or reports are unavailable, the business consequences are immediate. That changes how you think about correctness, testing, and the cost of assumptions.
- Building across the full stack — schema design, API behavior, frontend responsiveness — made the dependencies between layers hard to ignore. Slow queries show up in the UI; schema decisions constrain API flexibility. That cross-layer awareness is harder to develop when you stay within one layer.
Related Projects
Production systems built during employment at Peopleware MX
ZKTeco — Enterprise Biometric Integration
Built enterprise integration connecting ZKTeco biometric attendance hardware with payroll workflows. Architected resilient sync for unreliable device networks and distributed enterprise environments.
Google Sheets Enterprise Add-on
Migrated unstable legacy Excel add-in to Google Sheets add-on for enterprise payroll workflows. Full-stack delivery with React frontend, Apps Script runtime adaptation, OAuth2 authentication, and WebSocket synchronization within platform constraints.