Rust REST API and backend service built with Axum

Each engagement delivers a working Rust service straight into your repository, complete with automated tests and a README. Scope is fixed per tier, progress is shared through written updates, and there are no calls.

• Starter: up to 3 REST endpoints or a single background worker, source code, 1 revision
• Standard: up to 8 endpoints plus a PostgreSQL or SQLite database, source code, 2 revisions
• Advanced: up to 15 endpoints, authentication and continuous integration, source code, 3 revisions

Your project arrives inside your own repository, tested and documented, ready to run: a REST API on axum, a worker that consumes files or a queue, or a service that bridges your system with a third party's API. My background is eight years in web development before moving to Rust, and I maintain an open-source Rust crate on crates.io with documentation, continuous integration and roughly two hundred tests.

Starter covers one service: up to 3 REST endpoints, or a single worker reading from files or an existing queue, with tests, a README and the code placed in your repository. There is no database work at this tier. Standard extends this to up to 8 endpoints, adding PostgreSQL or SQLite with migrations, input validation, integration tests run against a test database, and a Dockerfile. Advanced covers up to 15 endpoints and adds token-based authentication with roles, a background worker, a CI pipeline that builds and tests on every push, and a deployment checklist tailored to the server you specify.

An endpoint is counted as a method paired with a path, so a GET and a POST to the same route count as two. Out of scope: front-end work, mobile apps, and smart contracts.

Every build runs on Tokio, the asynchronous runtime that axum sits on. There is no dependency on a particular host: it can run on a Linux VPS, inside Docker on a cloud platform, or on your own hardware. The Dockerfile is part of Standard and Advanced, and the Advanced checklist is written specifically for the deployment target you name.

On multi-day builds you receive a short written update each working day, with fast replies and no calls.

How the project runs

1. Scope agreed in writing: requirements, endpoint list and tier are confirmed before coding starts.
2. Repository and skeleton: the project structure and first working endpoint appear early so direction can be checked while changes are cheap.
3. Build phase: remaining endpoints or the worker are completed, each with its own tests, with daily written updates on longer builds.
4. Testing and packaging: integration tests against a test database, the README, the Dockerfile on Standard and Advanced, and the deployment checklist on Advanced.
5. Handover: the finished code sits in your repository with written notes on running, testing and deploying it.

What happens after you buy

Your order opens its own thread here the moment it is paid, and everything about that order - questions, changes and the final report - happens in it.

Questions people ask