MeetOnChai

Technology

TypeScript development.

Catch the bug in the editor, not in a customer's checkout.

TypeScript is the language under almost everything MeetOnChai Studio ships. MangoMasti, Oryizon, Shwetrex Pharma, WS Nepal, UniPay and ok.css are all written in it. We use it on the frontend, the backend and in mobile apps so one set of types describes your whole product.

Why we use it

Why TypeScript, and when not.

Plain JavaScript lets you pass the wrong thing almost anywhere and only find out when a user hits it. TypeScript catches a large share of those mistakes while the code is being written: a missing field, a misspelt property, a function called with the wrong arguments. On a checkout or a payment webhook, that is the difference between a red squiggle and a refund.

It also pays off after we leave. Types are documentation that cannot go out of date, so the next developer, ours or yours, can see what every function expects without reading all of it. Refactors become safer too: rename something and the compiler lists every place that needs to change.

When it's the wrong call: For a quick script, a one-off prototype you will throw away in a week, or a tiny static site, TypeScript setup can be more ceremony than value. And types are not a substitute for validation: data from users and third-party APIs still needs runtime checks, which is why we pair TypeScript with Zod at every boundary.

What we build

What we build with TypeScript.

  1. 01

    Full-stack web apps

    Next.js or React frontends with Node.js backends, sharing one set of types for every entity in the system.

  2. 02

    Type-safe APIs

    APIs where request and response shapes are checked on both sides, using tRPC, GraphQL codegen or OpenAPI.

  3. 03

    Payment layers

    Typed abstractions over gateways, like UniPay, so every provider returns the same event shape.

  4. 04

    Open-source libraries

    Packages with proper type definitions so they work nicely in other people's editors, like ok.css.

  5. 05

    JavaScript to TypeScript migrations

    Converting an existing codebase file by file, starting with the riskiest areas, without stopping feature work.

  6. 06

    Shared code for web and mobile

    Monorepos where a React Native app and a web app share types, validation and API clients.

The stack around it

What it ships with.

Language and checks
TypeScript (strict mode)ZodESLintBiome
Frontend
Next.jsReactReact Native
Backend
Node.jstRPCGraphQLPrisma or Drizzle
Workflow
pnpm workspacesTurborepoVitestGitHub Actions

Honest comparison

TypeScript vs the alternatives.

  • vs Plain JavaScript

    Faster to start and fine for small scripts. On anything with more than one developer or more than a few months of life, the missing safety net costs more than it saves.

  • vs JSDoc type annotations

    A lighter option that gets type checking without a compile step. Reasonable for small libraries, but harder to read and enforce across a product team.

Need hands, not a project?Hire Full-Stack Developers from our team

FAQ

TypeScript questions.

Does TypeScript make the website slower?

No. Types are removed before the code runs, so users get plain JavaScript. The only cost is a build step, and modern tooling makes that fast. Recent Node.js versions can even run TypeScript files directly by stripping the types.

Does TypeScript make development slower or more expensive?

There is a small upfront cost in writing types. It is usually paid back quickly in fewer bugs, safer changes and less time spent figuring out what old code does. On projects that live longer than a few months, we have found it saves time overall.

Can you convert our JavaScript project to TypeScript?

Yes, gradually. TypeScript and JavaScript can live in the same project, so we convert file by file, starting with the code that handles money, auth and data. Feature work does not have to stop while it happens.

Do you use strict mode?

Yes, on every new project. Strict mode is where most of the value is, because it forces handling of null and undefined, which is where a lot of real-world crashes come from.

Is TypeScript enough to prevent bad data?

No, and anyone who says otherwise is overselling it. Types only exist at build time. Form input, webhooks and third-party API responses are validated at runtime with Zod, and the types are derived from those schemas so the two never drift apart.

Every project starts with a conversation

Got an idea? Let's talk over chai.

A free 15-minute call. No pitch deck, no obligation. You leave with an honest read on what to build first.

  • We reply within 24 hours, usually much sooner.
  • NDA signed before you share the details.
  • Based in Kathmandu, working with Nepal, India and worldwide.