What services does A Major offer?

A Major offers web design, web app development, mobile app development (React Native, Swift, Flutter), SaaS product development, enterprise systems, UI/UX design, DevOps, performance optimization, MCP server development, AI agent infrastructure, MVP scoping, digital transformation, and engineering consultancy.

Where is A Major based?

A Major is based in Singapore and works with clients worldwide.

Do you work with international clients?

Yes. While headquartered in Singapore, A Major works with founders and businesses across Southeast Asia, Europe, and North America.

Ryu is an AI agent orchestration layer built by A Major. It enables teams to run, coordinate, and monitor AI agents at scale — connecting LLMs, tools, and workflows into reliable production systems.

Do you build MCP servers?

Yes. A Major builds Model Context Protocol (MCP) servers that connect AI agents to databases, APIs, and internal tools, enabling reliable LLM-powered workflows in production environments.

GraphQL vs REST — when should I use GraphQL?

Use GraphQL when: multiple clients (web, mobile, third-party) need different data shapes from the same API, your UI aggregates data from multiple resources in a single view, or you want end-to-end type safety via code generation. Stick with REST for simple CRUD APIs, public APIs that benefit from HTTP caching, or teams without GraphQL experience. A Major helps you evaluate the trade-offs for your specific project.

Is GraphQL slower than REST?

Not inherently — but poorly implemented GraphQL can be. The N+1 problem, deeply nested queries, and lack of CDN caching can make naive GraphQL slower than REST. With DataLoader batching, query complexity limits, persisted queries, and proper resolver optimization, GraphQL performance matches or exceeds REST for complex data fetching patterns.

Should I use Apollo or Relay on the client?

Apollo Client is more approachable — flexible, works with any GraphQL server, and has a gentler learning curve. Relay is Facebook's client — more opinionated, tighter schema conventions (connections, node IDs), but produces optimal queries and handles pagination elegantly. For most teams, Apollo Client is the practical choice. Relay shines in large-scale apps with strict schema conventions.

Can GraphQL replace REST entirely?

Technically yes, but pragmatically no for all use cases. GraphQL excels for read-heavy, relationship-rich queries. File uploads, webhooks, streaming responses, and simple CRUD operations are often simpler with REST. Many production architectures use GraphQL for the main API and REST for specific endpoints like file uploads and health checks.

GraphQL BackendA query language for APIs — ask for exactly what you need

GraphQL lets clients request exactly the data they need in a single query — no over-fetching, no under-fetching. We design GraphQL schemas, build performant resolvers, and implement federation for distributed teams.

GraphQL is a query language and runtime for APIs that lets clients specify exactly what data they need. Instead of hitting multiple REST endpoints and filtering out unwanted fields, a GraphQL client sends a single query describing the shape of the response — and the server returns exactly that shape. This eliminates over-fetching (getting too much data) and under-fetching (needing multiple requests), which is particularly valuable for mobile apps on slow networks and complex UIs that aggregate data from multiple sources. At its core, GraphQL is a type system. You define a schema — types, queries, mutations, and subscriptions — that serves as the contract between frontend and backend. This schema is introspectable (clients can discover what's available), validated at build time (invalid queries fail before they reach production), and enables powerful code generation. Tools like GraphQL Code Generator and Relay Compiler generate TypeScript types and React hooks directly from your schema, providing end-to-end type safety with zero manual type definitions. The challenge with GraphQL is that it moves complexity from the client to the server. Resolvers must handle N+1 query problems (DataLoader is essential), authorization must be enforced at the resolver level, and query complexity limits prevent malicious deeply-nested queries. For large organizations, Apollo Federation composes multiple team-owned subgraphs into a unified API gateway. A Major designs GraphQL schemas, implements performant resolvers with proper batching, and sets up federation architectures for teams that need a flexible, strongly-typed API layer.

Quick start

bash

# Create a new Apollo Server project
mkdir my-graphql-api && cd my-graphql-api
npm init -y
npm install @apollo/server graphql

# Create index.ts with a simple schema
# import { ApolloServer } from '@apollo/server';
# import { startStandaloneServer } from '@apollo/server/standalone';
#
# const typeDefs = `type Query { hello: String }`;
# const resolvers = { Query: { hello: () => 'Hello world!' } };
# const server = new ApolloServer({ typeDefs, resolvers });
# const { url } = await startStandaloneServer(server);
# console.log(`Server ready at ${url}`);

Read the full documentation at graphql.org/learn/

Schema-first API design

Strongly typed schemas define your API contract — every query, mutation, and type is documented and validated at build time. No more guessing what an endpoint returns.

Precise data fetching

Clients request exactly the fields they need — one query replaces multiple REST calls. Mobile apps fetch minimal payloads, dashboards fetch rich data, from the same API.

Real-time subscriptions

GraphQL Subscriptions push data to clients over WebSocket — live notifications, chat messages, and real-time dashboards powered by the same schema.

Apollo Federation

Compose multiple GraphQL services into a single unified schema — each team owns their subgraph, the gateway stitches them together transparently.

Code generation

Generate TypeScript types, React hooks, and SDK clients directly from your schema — end-to-end type safety from backend schema to frontend component.

Introspection & tooling

GraphQL is self-documenting — introspection queries expose the full schema. Tools like GraphiQL and Apollo Studio provide visual exploration, query building, and performance tracing.

Why it's hard

N+1 query problem

Naive resolver implementations trigger a separate database query for each related item — fetching 50 users with posts can trigger 51 queries. DataLoader solves this by batching and caching, but it must be implemented for every relationship.

Query complexity and security

GraphQL's flexibility is a double-edged sword — clients can construct deeply nested, expensive queries. Without query depth limits, complexity analysis, and rate limiting, a single malicious query can overwhelm your server.

Caching complexity

REST APIs cache naturally with HTTP caching (URLs map to cache keys). GraphQL uses a single endpoint with POST requests, making HTTP caching impossible. Client-side caching (Apollo, Relay) uses normalized stores, but CDN-level caching requires persisted queries or GET requests.

Schema evolution and versioning

GraphQL schemas don't version like REST APIs (v1, v2). Instead, fields are deprecated and new fields are added. Managing this evolution across clients — especially mobile apps that can't be force-updated — requires careful deprecation policies and field tracking.

Best practices

Use DataLoader for every relationship

Implement DataLoader for batching and caching at the resolver level. Without it, a list query fetching N items with M relations triggers N*M database queries. DataLoader collapses these into 2 queries — one for items, one for all related items.

Implement query complexity limits

Assign cost values to fields and limit total query complexity. A deeply nested query requesting all users → posts → comments → likes could return millions of rows. Use graphql-query-complexity or Apollo's built-in cost analysis.

Generate types from schema

Use GraphQL Code Generator to create TypeScript types, React hooks (useQuery, useMutation), and server-side resolver types from your schema. This ensures frontend and backend stay in sync without manual type maintenance.

Design schemas for client needs, not database structure

GraphQL schemas should model the domain as clients need it — not mirror your database tables. Use connections for pagination, dedicated input types for mutations, and meaningful field names that read naturally in queries.

Useful resources

GraphQL Official Documentation Apollo GraphQL GraphQL Code Generator GraphQL Community on Discord

Frequently asked questions

Node.js

JavaScript all the way down

React

Fast, interactive UIs that users love

tRPC

End-to-end typesafe APIs without code generation

Looking for end-to-end delivery? These services complement GraphQL projects.

Want to build with GraphQL?

Talk to our engineering team about your GraphQL architecture. We'll respond within 24 hours.

1 spot available in May 2026Apr 2026 fully booked

We limit intake each month so every project gets the focus it deserves.

GraphQL BackendA query language for APIs — ask for exactly what you need