Our Work What We Stand For How We Work Why We're Different Start a Conversation Message Us on WhatsApp

International engineering team · Architect-led development Complete handover, no lock-in

Cross-Border Inventory Platform

$180K → $3K
Inventory discrepancy per quarter
40%
More orders per shift
6 weeks
To deliver
3× peak
Volume, zero degradation

A logistics operator managing 50,000+ SKUs across warehouses in Hong Kong and Shenzhen needed a unified system. Their existing setup — spreadsheets plus a legacy desktop application — couldn’t handle real-time stock movement between locations.

The Core Challenge

Inventory data was splitting across two systems with no shared source of truth. Warehouse staff in Shenzhen updated stock counts on a local tool. The Hong Kong office ran reports from a different spreadsheet. Discrepancies appeared daily — sometimes costing the client six-figure write-offs per year.

How It Works

01
Order Placed
Customer places order via any channel
02
Stock Verified
System checks real-time inventory across locations
03
Warehouse Notified
Nearest warehouse receives pick instruction
04
Status Updated
All locations see updated counts instantly

What We Chose & Why

MongoDB PostgreSQL + row-level locking
Zero data loss under contention
Polling Redis pub/sub real-time sync
300ms cross-warehouse updates
Standard web app Offline-first React
Works through Wi-Fi drops
Big-bang delivery 6-week milestones
Client approved each phase

Other Projects We've Engineered

FinTech

Multi-Currency Settlement Engine

Result Settlement time: 48 hours → 6 minutes

Cross-border payment reconciliation for a Hong Kong–Shenzhen trading firm processing 12,000+ daily transactions across HKD, CNY, and USD.

The core difficulty was exchange rate fluctuation and settlement timing differences across three currencies. A single transaction could show as confirmed on the HKD side while the CNY leg was still pending — the old process had two accountants manually matching records the next day. We built a real-time rate snapshot with event-driven reconciliation: each transaction auto-matches once confirmed across all currencies, with discrepancies flagged instantly. Work that used to take two staff a full day now completes automatically.

PostgreSQLNode.jsRedis Streams
B2B Commerce

Cross-Border Wholesale Platform

Result Order processing: 2 days → 4 hours

Online ordering system for a manufacturer selling to distributors across Southeast Asia. Multi-currency pricing, bulk order management, and ERP integration.

This company was taking orders via WhatsApp, quoting in spreadsheets, and collecting payments through bank transfers — three full-time staff on order processing alone, still making frequent errors. The hardest part was integrating their decade-old ERP: missing API documentation, inconsistent data formats, and fields that relied on staff intuition. Rather than forcing a system replacement, we wrote an adapter layer that treated the legacy system as a data source. Distributors now self-serve — browse stock, see live pricing, place orders that sync back to the ERP automatically.

Next.jsPostgreSQLStripe
PropTech

Commercial Property Management

Result Maintenance response time reduced 60%

Unified tenant management, maintenance ticketing, and energy monitoring platform for a property company overseeing 15+ commercial buildings.

The typical property management pain: tenants report issues by phone, building managers prioritise from memory, and energy data sits in each building's isolated system with no cross-comparison. A single water leak ticket took an average of 3 days from report to repair, because information bounced between WeChat groups, phone calls, and paper forms. We built a closed loop — tenants submit on mobile, the system auto-assigns based on ticket type and technician location, with full progress tracking. Management now sees response times and costs across all buildings in one dashboard.

ReactNode.jsIoT Integration
AI Automation

AI-Powered Customer Service

Result 70% of routine inquiries auto-resolved

Automated support ticket classification, knowledge base matching, and draft response generation for a mid-size SaaS company.

The client's support team was handling 200+ tickets daily, most of them repetitive: password resets, feature how-tos, billing queries. But manual classification was error-prone — technical issues landed with non-technical agents, causing time-wasting handoffs. Our system doesn't replace support staff. It classifies incoming tickets, matches them against the knowledge base, and drafts a reply for the agent to review before sending. The critical design choice: every AI-drafted response requires human approval. No automated replies go directly to customers — this was a non-negotiable trust requirement.

PythonLLM APIPostgreSQL

Engineering Opinions That Shape Every Project

These aren’t marketing slogans. They’re engineering positions we’ve taken based on what we’ve seen work — and fail — in production.

We choose proven technology over trending frameworks

PostgreSQL, Redis, React, Node.js — battle-tested tools with deep ecosystems. When a client’s business depends on uptime, we don’t experiment with their production environment. The newest framework is exciting on Hacker News. It’s terrifying in a production incident at 2 AM.

We refuse to ship without load testing

Every system we deliver is tested under 3× expected peak traffic before launch. Not because clients ask for it — most don’t know to ask. Because a system that fails under real load is a system we failed to build properly.

Architecture decisions are never delegated to junior engineers

The founding engineer designs every system architecture personally. Database schema, API contracts, deployment topology, security model — these decisions compound. A wrong choice at the foundation costs 10× to fix six months later.

Complete code ownership on delivery

When the project ships, we hand over all source code, technical documentation, and deployment configuration. No vendor lock-in — if you want to bring development in-house or switch partners later, you can. Your code is your asset, not our leverage.

From Our Terminal

Short technical insights from real projects. The kind of detail we think about so you don’t have to.

advisory-locks.sql
2025-06

Advisory Locks for Concurrent Stock Updates

SELECT pg_advisory_xact_lock( hashtext(warehouse_id || sku) ); UPDATE inventory SET quantity = quantity - $1 WHERE sku = $2 RETURNING quantity;

When two warehouse workers scan the same SKU within milliseconds, row-level locks create contention queues. Advisory locks on a composite key let us serialize only conflicting SKU updates — everything else processes in parallel with zero contention.

wechat-detect.ts
2025-05

WeChat Browser Detection and CSS Fallback

const isWeChatBrowser = /MicroMessenger/i.test( navigator.userAgent ); if (isWeChatBrowser) { document.body.classList .add('wechat-env'); }

WeChat’s in-app browser silently ignores backdrop-filter. Every glass-card in our Hong Kong projects needs a solid-background fallback triggered by user-agent sniffing — otherwise clients opening a shared link in WeChat see broken transparency.

redis-ordering.ts
2025-04

Message Ordering in Redis Pub/Sub

// Redis pub/sub doesn't guarantee // cross-channel ordering. // Use Streams for sequential processing. const id = await redis.xadd( 'inventory:events', '*', 'action', 'decrement', 'sku', sku, 'qty', String(qty) );

We learned this the hard way: Redis pub/sub delivers messages per-channel but makes no ordering promise across channels. For inventory events that must process sequentially, we switched to Redis Streams — append-only logs with consumer groups that guarantee exactly-once processing.

offline-queue.ts
2025-03

Offline Queue with Conflict Resolution

async function syncQueue() { const pending = await idb .getAll('offline_ops'); for (const op of pending) { const result = await api .submit(op); if (result.conflict) await resolveByTimestamp( op, result.serverState ); } }

Warehouse Wi-Fi drops unpredictably. Our tablet apps queue operations in IndexedDB and sync on reconnect. Conflicts resolve by timestamp with server-state wins — simpler than CRDTs, and warehouse staff never see a sync error.

Four Phases. Your Approval at Every Gate.

01

Understand

We listen. What does your business actually need? Not what features you think you want — what problem are you solving? We map your business process before writing a line of code.

Week 1
02

Architect

The founding engineer designs the system architecture, database schema, and deployment plan. You review and approve the technical blueprint before we start building.

Week 2
03

Build

Iterative development with regular demos. You see real, working software in short cycles — not status reports. Modern tooling accelerates our implementation the same way power tools help a master carpenter build faster, without replacing their craftsmanship.

Week 3–6
04

Ship

Load testing, security review, deployment. We don’t just hand over code — we ensure it runs reliably in production. Post-launch transition support included to get you running smoothly.

Week 6–12
async function processOrder(order) {
const validated = await validate(order);
const inventory = await checkStock(validated);
return await fulfil(inventory);
}
Architecture Review Engineering Review Load Testing Your Approval

Every phase, you approve before we proceed. Milestone-based payments — you pay for delivered results, not time spent.

Three Paths. Choose Wisely.

Every business building software faces the same decision. Each path has real trade-offs.

Budget Development

Freelancers or offshore teams. Lowest upfront cost, least technical depth.

  • Fast initial delivery, often within weeks — though quality varies
  • No dedicated architect — code structure varies by developer
  • Limited testing and security review before launch
  • System may need significant rework as requirements grow

Traditional Agency

Larger teams with structured processes. Higher price point.

  • Teams split across multiple client projects simultaneously
  • Senior staff lead sales; junior developers handle most coding
  • Typical timelines of 6–12 months, with unpredictable post-launch costs
  • Higher total investment including project management overhead

We’re not the cheapest option. We’re not the biggest firm. We’re the engineering team that treats your project like their own product.

Tell Us What You're Building

Send a message. We’ll reply with honest feedback.

Message Us on WhatsApp

Your message reaches the team directly. We typically respond within a few hours.

or leave your details

No sales pitch. No obligations.

WhatsApp Us