Frontend
- React
- Next.js
- TypeScript
- Tailwind CSS
- Astro
Our Technologies
A modern stack, chosen for longevity
We pick technologies for how well they'll serve you in five years — well-supported, hireable, and proven — not for what's trending this month. Here's what we build with.
Backend
- Node.js
- NestJS
- Python
- REST & GraphQL APIs
Mobile
- React Native
- Flutter
- Native iOS (Swift)
- Native Android (Kotlin)
Databases
- PostgreSQL
- MySQL
- MongoDB
- Redis
Cloud & DevOps
- AWS
- Docker
- CI/CD pipelines
- Vercel
AI & Data
- LLM integration
- OpenAI / Anthropic APIs
- Workflow automation
- Analytics
Payments & Local
- Stripe
- PayNow
- PayPal
- Singapore integrations
Security & Compliance
- PDPA-compliant
- OWASP practices
- Encryption
- Role-based access
Stack in depth
What we use and why it matters to you
Technology decisions have downstream consequences for cost, reliability, and how easy the system is to hand over or extend. Below is a plain-English account of each layer.
Front-end — web
We build web interfaces in React with TypeScript, often through Next.js when server-side rendering or static generation helps with performance and SEO. TypeScript catches entire categories of bugs before they reach production, which matters for long-lived client systems. For content-heavy or marketing sites we use Astro, which ships minimal JavaScript and loads fast on lower-end connections — relevant in a market where mobile browsing is the norm.
Back-end & APIs
Server-side logic runs on Node.js — either lightweight Express services or structured NestJS applications for larger systems that benefit from enforced module boundaries and dependency injection. Where data processing or machine-learning tasks fit Python better, we use it there and expose the results through a clean REST or GraphQL API. Keeping the API layer explicit means your front-end, mobile apps, and third-party systems can all consume the same data without duplicate logic.
Mobile — iOS & Android
React Native is our default for business apps that need to reach both iOS and Android from a shared codebase — it cuts development time substantially and shares logic with existing web back-ends. Where a project needs deep device integration, high-performance graphics, or very specific platform behaviour, we build with native Swift (iOS) or Kotlin (Android). Flutter is an option when a pixel-perfect, highly animated interface is a hard requirement. We recommend the approach that fits your users and your maintenance budget, not the one that's easiest for us.
Databases
PostgreSQL is our first choice for most business applications: it is mature, well-understood by the developer market, supports strong consistency, and handles complex relational queries efficiently. MySQL suits projects that already sit inside a MySQL-based ecosystem. MongoDB is appropriate when documents genuinely vary in shape — product catalogues, CMS content — but we do not use it as a default, because schema-less storage often creates maintenance pain later. Redis handles caching and session storage, keeping frequently-read data fast without repeated database round-trips.
Cloud & DevOps
Most projects run on Amazon Web Services, using managed services for databases, queues, object storage, and compute so that operational overhead stays low. We containerise applications with Docker to make environments reproducible from local development through to production. Automated CI/CD pipelines mean every push through the main branch is linted, tested, and deployed consistently — no manual FTP uploads or "works on my machine" surprises. Infrastructure is documented so your internal team or any competent provider can take it over.
AI & LLM integration
We integrate large-language-model APIs — primarily from OpenAI and Anthropic — into workflows where they add clear value: document parsing and extraction, customer-facing chat, content drafting assistance, and internal knowledge search. We design these integrations with guardrails: structured output validation, graceful fallback when the model is uncertain, and audit trails so staff can review AI decisions. AI features are built as opt-in enhancements to existing processes rather than replacements that remove human oversight.
Integrations — payments, messaging & local APIs
For payments we integrate Stripe (cards, recurring billing), PayNow (Singapore QR and bank transfer), and PayPal where international acceptance is needed. Messaging uses SendGrid or Mailgun for transactional email and Twilio for SMS — both are reliable, well-priced at SME volumes, and have straightforward local delivery. For Singapore government integrations we support Singpass and Myinfo Login so users can authenticate or pre-fill forms with verified personal data, reducing friction and manual verification. Accounting integrations with Xero connect invoices, payments, and job records to the systems finance teams already use.
Security & PDPA compliance
Security is built in, not bolted on. We follow OWASP Top 10 guidance to prevent common vulnerabilities — SQL injection, cross-site scripting, insecure direct object references — through code review and automated scanning. Data at rest is encrypted; data in transit uses TLS. Role-based access control limits what each user can see or do, which matters both for internal misuse and for demonstrating PDPA accountability. We can help clients document their data inventory and retention policies to meet PDPA obligations, including the mandatory breach notification requirements.
How we decide
Principles behind every stack recommendation
Before recommending any technology, we weigh four things: does it solve the actual problem, is it necessary to build at all, does it tie you to a single vendor, and can other developers pick it up without our involvement?
Fit-for-purpose over fashionable
A technology is on the list because it solves a real problem reliably, not because it was written about recently. We stay current but we are sceptical of early adoption when your production system carries real business risk.
Build only what cannot be bought
Commodity infrastructure — email delivery, payments, SMS — should come from established providers. We build the parts of your system that are genuinely specific to your business and wire the rest together through stable APIs.
No proprietary lock-in
We document every system thoroughly and use open standards wherever possible. If you decide to change vendor or bring development in-house, you should be able to. We have no interest in holding a system hostage.
Hireable on the open market
Every framework and language we choose has a broad pool of competent developers. If your team grows and you need to hire, or if you move to a different agency, the stack should not be an obstacle.
The right tool for your project — not a one-size-fits-all stack
Every project is different. We recommend the stack that fits your budget, timeline, team, and how long the system needs to last — then we build it to enterprise standards and document it so anyone can maintain it.