Skip to content

Custom software: web apps and internal tools

ozeida builds custom software for businesses from Saltillo, Coahuila, Mexico: web applications, customer and vendor portals, internal tools, APIs and integrations, using Next.js, Rust and AWS. The code lives in the client's repository, with automated tests, reproducible deployment and documentation. We work nearshore, in US Central time.

Tell us about your projectHow we work

Updated

What we build

  • Web applications

    To run a process no off-the-shelf tool covers well: orders, inventory, quoting, tracking, quality.

  • Portals

    For customers, vendors or distributors, with per-user access and live data from your systems.

  • Internal tools

    That replace shared spreadsheets, email threads and manual steps.

  • APIs and integrations

    Between systems that don't talk to each other today (ERP, CRM, billing, logistics, banking).

  • Applications with AI built in

    When the process calls for it.

    AI implementation
Ink drawing of two hands fitting a hand-cut paper piece into a hollow of exactly the same shape.

What we build with, and why

  • Next.js and React with TypeScript

    For the interface: fast to load, accessible, typed end to end.

  • Rust on AWS Lambda

    For business logic: low resource use, no servers to patch, errors caught at compile time.

  • Postgres or DynamoDB

    Depending on the case; Cognito for users and permissions; CloudFront in front of anything public.

  • Infrastructure as code and CI/CD

    From day one: every change passes tests before reaching production.

    AWS cloud & DevOps

  • Design

    Restrained and consistent: dark or light, Inter typeface, accessible components. No purchased templates.

If your team already runs a different stack, we respect it when it makes sense; we don't rewrite what works.

How we work

  1. Scope in writing

    A short document with what's in, what's out, and how we'll know it's done.

  2. Deliveries every two weeks

    To a staging environment you can use from the first one.

  3. Automated tests

    Unit and end-to-end; nothing deploys unless they pass.

  4. Production and handover

    Code in your repository, operations documentation, a handover session with your team.

  5. Optional support

    With agreed response times and monitoring through ozeida Quality Control.

    Quality Control

What you get

  • A repository under your name with full history.
  • Automated tests and a deployment pipeline.
  • Reproducible infrastructure (CDK or SAM) in your AWS account.
  • Documentation: architecture, operations, how to make changes.
  • Accessible design (keyboard, contrast, reduced motion).

How code quality is checked

Code quality is verified, not promised: every change goes through code review, through automated tests that run in the continuous-integration pipeline before any deployment, and is documented in the client's repository. If the tests don't pass, the change doesn't reach production.

What does every change go through before production?

  1. The compiler and the type system. Rust on the backend and strict TypeScript on the front end catch a share of the errors before a test exists to look for them.
  2. Automated tests. Unit tests (Vitest, cargo test) and end-to-end tests (Playwright) on the flows that matter: create an order, close a quote, change a permission.
  3. Code review. Someone else reads the change before it's merged; on a small team that includes the founder.
  4. A pipeline with gates. GitHub Actions runs all of the above on every change. A deployment only happens when the pipeline is green, and it can be rolled back.
  5. Post-deploy verification. "Deploy succeeded" is not "the application works"; we check the second one.

How do I know the tests actually exist?

Because the repository is yours from day one. You can open the test folder, see the pipeline history on every change, and ask for any delivery to include the test report. You don't have to trust a description; it's in the repo.

What if my team has to maintain it afterward?

Technical documentation (architecture, how to run the tests, how to deploy, how to make a change) lives in the same repository, and handover includes a session with your team. The goal is that they can maintain it without depending only on us; ongoing support is optional and agreed by contract.

Custom software FAQ

Who owns the code?

You do. The repository is under your name from the start, with full history, and you can take it to another vendor whenever you want.

How much does it cost and how long does it take?

The price is set in writing from the scope, before we quote. Deliveries are every two weeks, so you see usable progress from the first one.

How does working with a nearshore team in Mexico actually go?

Daily overlap with US Central and Eastern hours, English as the working language, async updates in writing, and a short flight from Texas when an in-person session helps. Contracts in English and USD invoicing.

Why Rust instead of something more common?

On Lambda it starts fast, uses little memory (your AWS bill goes down) and the compiler catches errors before production. For the interface we use Next.js, which is common. If your team needs another language to maintain it, we evaluate that.

Can you integrate with our ERP or CRM?

Yes, as long as it has an API or database access. Before quoting we check what your system exposes and what it doesn't.

Do you work alongside an in-house engineering team?

Yes. We can build with your team, hand over at the end, or stay on for operations. That's decided in the contract, not on the fly.

How do you make sure the code you deliver is solid?

Code review, automated tests (unit and end-to-end) and continuous integration on every change: nothing deploys if the tests fail. Technical documentation stays in your repository so your team can maintain the system without depending only on us.

You may also need

Which process needs its own tool?

Tell us what your team does by hand today and we'll tell you what's worth building and what isn't.

Tell us about your project