Hello, I'm
Jerick SonIcamina
I build the systems companies run on daily operations.
10+ years designing warehouse management platforms, internal business tools, and backend architectures in Golang, TypeScript, and React — end-to-end, from data model to production.
About
Over the past decade I've designed, built, and operated the kinds of systems that businesses depend on daily — warehouse management platforms, sales automation tools, e-commerce configuration engines, and data processing pipelines. I own these systems end-to-end: from the data model and API design through the mobile and web interfaces that operations teams use on the floor.
My focus is on the engineering decisions that determine whether a system holds up under real conditions — concurrency control when multiple warehouse stations modify the same inventory, offline-first architectures for mobile devices with unreliable connectivity, pricing consistency across distributed dealer networks. I choose tools and patterns for the constraints of the problem, not the hype cycle.
I've shipped production systems in Golang, TypeScript, and PHP. I select the language and runtime based on the domain: Golang for concurrent backend services, TypeScript for web and mobile interfaces, PHP/Laravel when rapid delivery with strong ORM support is the right trade-off.
10+
Years in Production Systems
5
Mission-Critical Systems in Production
3
Backend Languages Shipped
Engineering Focus
The problems I gravitate toward and the kind of thinking I bring to production systems.
System Design & Architecture
Defining service boundaries, data models, and consistency guarantees for business-critical systems. Example: designed an event-sourced inventory model with optimistic concurrency control for a warehouse management system — ensuring stock levels never drift even under concurrent multi-station access.
Operational & Internal Tools
Building the software that operations teams rely on daily — inventory tracking, automated report generation, sales proposal engines. Example: replaced a manual Word-document proposal workflow with a rules-driven PDF generation engine that reduced offer creation from hours to minutes.
End-to-End System Ownership
Owning the full vertical: database schema, backend services, API contracts, web dashboards, and mobile companion apps — delivered as cohesive systems. Example: built a WMS spanning a Golang backend, PostgreSQL data layer, Svelte dashboard, and React Native mobile app for warehouse floor operations.
Reliability Under Real Constraints
Engineering for the environments where software actually runs — warehouse floors with intermittent WiFi, sales teams generating hundreds of concurrent proposals, dealer networks that need pricing consistency. Example: implemented offline-first mobile sync with conflict detection that flags stock exceptions rather than accepting invalid state.
Case Studies
Production systems I've designed and delivered — from problem definition through architecture, implementation, and ongoing operation.

Herco IRIS
— Warehouse Management SystemAn integrated warehouse management system running daily operations for a mid-size trading company — inventory receiving, put-away, cycle counting, pick-pack-ship fulfillment, stock transfers, and management reporting across multiple warehouse zones with thousands of active SKUs.
Problem
The company tracked inventory in spreadsheets. When a receiving clerk logged inbound stock, that update wasn't visible to the picking team until someone manually reconciled the sheet — sometimes hours later. This created a class of problems: overselling products that were committed but not yet shelved, stock "appearing" in the wrong zone because location updates lagged behind physical movement, and fulfillment delays because pickers couldn't trust what the spreadsheet said was available. At the operational level, the root cause was simple: no single source of truth for stock state, and no transactional guarantees when multiple people modified inventory simultaneously.
Solution
Designed and led development of IRIS — a system that replaced the entire spreadsheet-based workflow with transactional inventory management. The core design principle was that every stock movement (receive, put-away, pick, transfer, adjustment) is recorded as an immutable event, and current stock levels are derived from the event log. This gave the operations team an auditable history of every unit that moved through the warehouse, and gave the system a foundation for enforcing consistency even under concurrent access.
Scale
Thousands of active SKUs across multiple warehouse zones. Concurrent daily users across receiving, picking, and shipping stations. The system handles the full inventory lifecycle — from purchase order receipt through customer shipment — processing stock movements continuously throughout the operating day.
Architecture
Golang was chosen for the backend because the core domain is concurrent stock manipulation — goroutines and channels map naturally to handling simultaneous warehouse operations without the overhead of a JVM or the concurrency complexity of Node.js. PostgreSQL was selected over MySQL for its row-level locking semantics and SERIALIZABLE isolation support, which were critical for the inventory consistency model. The Svelte web dashboard serves warehouse managers and back-office staff. React Native was chosen for the mobile app because floor staff need barcode scanning and location confirmation on devices that may lose connectivity between warehouse zones.
Data Model
The inventory model is event-sourced at the movement level. A stock_movements table records every unit change with a movement type (RECEIVE, PUTAWAY, PICK, TRANSFER, ADJUST, SHIP), source/destination location, quantity delta, and a reference to the originating order or transfer. Current stock levels are materialized in a stock_on_hand view partitioned by (sku_id, location_id). Each SKU-location pair carries a version counter used for optimistic concurrency control — any write that finds a stale version is rejected and retried. Warehouse locations follow a zone → aisle → rack → bin hierarchy, modeled as a nested set for efficient subtree queries when checking zone-level availability.
Engineering Challenges
Concurrent Pick and Receive on the Same SKU
The most common race condition: a picker reserves 5 units of SKU-A from Zone-B while a receiving clerk simultaneously logs 20 new units of SKU-A into Zone-B. Without protection, the pick could succeed against stale stock levels, or the receive could overwrite the pick's decrement. The solution uses SELECT ... FOR UPDATE on the stock_on_hand row for the specific (sku_id, location_id) pair, combined with a version check. The first transaction to commit wins; the second detects the version mismatch, re-reads current stock, and retries. This adds latency (~10-50ms per retry) but guarantees that stock levels never go negative and that no two operations silently overwrite each other.
Offline-First Mobile in Low-Connectivity Zones
Parts of the warehouse have unreliable WiFi coverage. If the mobile app required constant connectivity, pickers would be blocked mid-workflow. The mobile app queues operations locally using a write-ahead buffer and syncs when connectivity resumes. The tricky part is conflict resolution: if a picker confirms a pick offline, and by the time it syncs the stock has already been allocated elsewhere, the system flags a stock exception for manual review rather than silently accepting potentially invalid state. This was a deliberate trade-off — correctness over convenience.
Zone-Based Storage with Location Hierarchy
Operations staff needed to query availability at different levels of granularity — "how much of SKU-X is in Zone A" vs. "what's in Aisle 3, Rack 2, Bin 4." A flat location model would require expensive aggregation queries. Modeling locations as a nested set (zone → aisle → rack → bin) with pre-computed left/right boundaries allows a single range query to aggregate stock across any subtree. The trade-off is that location restructuring (adding a new aisle) requires re-numbering the nested set, but warehouse layouts change infrequently — this was an acceptable cost for the query performance gain.
Trade-offs
Chose Golang over Node.js for the backend despite the team having more TypeScript experience. The concurrency primitives (goroutines, channels, select) made the stock processing pipeline significantly cleaner than callback-based alternatives, and the compiled binary simplified deployment to the on-premise server. Chose event-sourced stock movements over a simpler current-state-only model because auditability was a hard requirement — operations needed to trace exactly how stock levels arrived at their current values. The cost is higher storage and slightly more complex queries, but the debugging and reconciliation benefits justified it. Chose optimistic concurrency (version checks) over pessimistic locking for most operations because throughput mattered more than strict ordering — warehouse operations are high-frequency but low-contention at the individual SKU-location level.
Failure Handling
If the backend goes down mid-pick, the mobile app's local buffer holds the operation until reconnection. Partially completed multi-item picks are tracked as in-progress; if not completed within a configurable timeout, they're automatically rolled back and the reserved stock is released. If PostgreSQL enters a degraded state, the system switches to read-only mode — staff can view current stock but cannot process movements until the database recovers. This prevents silent data corruption during partial availability.
Impact
Eliminated spreadsheet-based tracking entirely — the company now operates on a single, transactional source of truth for all inventory. Stock discrepancy rate dropped from regular manual reconciliation events to exception-only investigation. Order fulfillment shifted from a multi-step, error-prone manual process to a guided mobile workflow that enforces correctness at each step. The system processes the full daily operational throughput without manual intervention.

Vehicle Configuration Platform
— Subaru AustraliaA vehicle configuration and quotation platform enabling Australian customers to build custom Subaru vehicles with real-time pricing, and providing dealers with unified tools for offer and accessory catalog management.

Financial Research Platform
— Valens ResearchA data-intensive financial research platform delivering proprietary analytics and interactive visualizations to institutional investors — replacing desktop-only tooling with web-native, explorable financial models.

Energy Services Platform
— Smart Energy Solutions UKAn end-to-end platform automating customer energy assessments and branded PDF offer generation for a UK energy services provider — replacing a manual, document-assembly process with a rules-driven generation engine.

Sales Report Converter
— Internal Automation ToolAn internal data pipeline that transforms vendor sales reports — arriving in inconsistent PDF and Excel formats — into structured, analysis-ready Excel outputs, eliminating hours of weekly manual data re-entry.
Technical Stack
Chosen for the problem, not the trend. Each technology below is something I've shipped to production and can speak to the trade-offs of.
Frontend


Backend




Database


Also Experienced With
AI-Augmented Workflow
I use AI tooling to ship faster without cutting corners on the decisions that keep systems reliable in production.
More Time on Architecture, Less on Boilerplate
AI handles scaffolding, pattern exploration, and repetitive implementation. That means more of the project timeline goes to the work that actually determines outcomes — data modeling, failure mode analysis, and getting the system boundaries right before the first deploy.
I Own the Design Decisions
System boundaries, concurrency models, data contracts, and failure handling — these are the decisions that determine whether a system holds up at scale or fails silently. I make those calls based on a decade of operating the kinds of systems where getting it wrong means warehouse floors stop moving.
Every Line Validated Against Production
Generated code gets reviewed against the same bar as hand-written code — edge cases from real operations, domain invariants, and how the full stack behaves under load, partial failure, and concurrent access. The output ships; the accountability stays with me.
Let's Build Something Real
I'm interested in complex systems work — warehouse operations, internal tools, data-heavy platforms, and anything that needs to survive contact with real users. If you're building something non-trivial, let's talk.