TempMovers: Database, Payments and Launch Build

Client Work / Web Application / Database Migration / Stripe Payments

A working foundation for an Indianapolis moving marketplace, delivered in eight days: the database created and proven, the build repaired, Stripe pay-before-dispatch checkout and a live launch signup.

Watch the project walkthrough

A walkthrough of the database, booking, payment and launch work delivered for TempMovers. Watch on Vimeo →

TempMovers had a finished eleven-portal platform, but its database had never been created, the application would not build and the domain did not resolve. Vasrue Digital Media created and proved the database, repaired the build, added junk-removal booking and pay-before-dispatch checkout, put a launch signup live and handed everything back with its full history.

Client: TempMovers, Indianapolis  ·  Engagement: Upwork, fixed price  ·  Delivered: 23–30 October 2026 (contract closed 2 November)  ·  Role: lead developer and database engineer, Clinton Douglas IV, Vasrue Digital Media  ·  Client rating: ★★★★★ 5.0 on Upwork

TempMovers platform preview on a desktop screen beside the junk-removal booking flow on a phone, both marked Preview, sample data, not the live app
The platform preview on desktop and junk-removal booking on a phone. Both carry the “sample data, not the live app” banner, which is accurate.
97tables in the first migration, zero destructive statements
34 → 0type errors; the production build went from failing to passing
355passing automated tests, plus 27 of 27 permission tests
52 / 52end-to-end payment checks in Stripe test mode

These are recorded delivery outcomes from October 2026. Figures visible inside the preview screens are sample interface content, not business results.

At a glance

ClientTempMovers, a two-sided marketplace for moving labor, box-truck delivery, freight and junk removal, launching in Indianapolis
Our roleLead developer and database engineer: migration, payments, feature build, launch pages and handover
The jobDatabase Migration & Permission Checkpoint: Next.js / Prisma / PostgreSQL
TimelineCheckpoint delivered in five days; the full build and handover in eight
StackNext.js 15 · React 19 · TypeScript · Prisma · PostgreSQL 18 on Neon · Vercel · Stripe · Vitest
ResultDatabase live and proven, application building and passing 355 tests, payments working end to end in Stripe test mode, domain live with a working launch signup, and everything handed over with its full history and backups

The story behind it

TempMovers didn’t find us on a job board. The founder came to Vasrue directly, through an existing relationship. He had a platform he’d spent months putting together and a launch he wanted on the calendar. We brought the engagement onto Upwork on purpose: he got escrow protection and a public, verified record of the work, and we got a written contract to build against. Before he posted, we scoped the job with him, so the contract described the platform he actually had, not a generic “connect my front end to my back end” request.

The platform was large and ambitious: a Next.js and Prisma codebase with a frozen schema of 97 tables, a test suite and a stack of launch documents. It had eleven portals, one each for customers, movers, drivers, carriers, shippers, dispatchers, administrators and recruiting. What it didn’t have was a database. The schema had been written and reviewed, but it had never been created anywhere, not even once. Everything had been checked as code only. On top of that, his domain wasn’t resolving.

His standard was clear from his own posting: nothing gets marked as passed on code review alone. Prove it on a throwaway copy first. Capture evidence at every step. Give him the actual results, not a summary. That’s how we work anyway, so the fit was right from the first call.

TempMovers launch page with a two-list waitlist signup for customers and workers
The delivered launch page, with its two-list signup for customers and workers, captured in the project archive.

What we found in the first hour

  • No database had ever existed. No migration had ever been generated, let alone applied.
  • The application couldn’t be built. Type-checking failed in 34 places, and the production build failed outright.
  • Security advisories. The web framework carried three critical security advisories.
  • Unstyled screens. Eighteen of the newer portal screens rendered with no styling at all. They had been written for a CSS framework that was never installed.
  • A self-contradicting runbook. In one place, a step forbade a database change that the next step required. In another, it asked for proof that eight feature flags were switched off, but the seed data never created those flags.
  • A dead domain. It was registered with one provider and pointed at another provider’s nameservers, which weren’t answering.

Behind most of it was one pattern: three half-finished migrations, each 80 to 95 percent complete and then abandoned. Seeing that early meant we could fix causes instead of chasing symptoms.

TempMovers platform home page in the public click-through preview, with sample statistics
The public click-through preview, which takes visitors into all eleven portals. Visible statistics are sample content.

What we did

1. Database and application engineering: the checkpoint he hired us for

  • First migration, read before use. We generated it offline from his frozen schema and read it line by line before applying anything. It contained zero destructive statements.
  • Applied on Neon, one branch per environment. We applied it to a clean PostgreSQL database on Neon, with separate database branches for production, staging and throwaway testing. The result was 97 tables, 85 enum types and 135 foreign keys, with a schema fingerprint identical to his frozen copy.
  • Permission suite passing. For the first time, his permission suite ran against a real database: eleven negative-permission scenarios, 27 tests, all 27 passing.
  • A green build. We took the application from “cannot build” to green: zero type errors, a passing production build, and 310 automated tests across 31 files.
  • Security fixed. We patched the three critical framework advisories and locked the dependency tree.
  • Screens restored. We installed the missing CSS framework without disturbing his original design system, so all eighteen unstyled portal screens rendered properly.
  • Runbook settled with evidence. We resolved both runbook contradictions, and made the seed create all eight feature flags, each one switched off.
  • Backups proven, not assumed. We damaged a copy of the database on purpose by dropping one table and emptying another, then restored it to a point in time and matched every count against the baseline.
  • Written for his team. We wrote an evidence packet that maps to his own launch-blocker register, and an operations how-to his team can run from.
Customer portal preview listing sample moves, crews and receipts
Customer portal preview. Sample moves, crews and receipts; a public preview, not a private account.
Mover portal preview showing sample jobs near the mover with a guaranteed flat rate
Mover portal preview. Sample job discovery and acceptance.
Carrier dashboard preview showing verification, insurance and documents
Carrier portal preview. Sample verification, insurance and documents.
Dispatch board preview with sample active loads
Dispatch portal preview. A sample board for coordinating marketplace work.
Admin portal preview with the carrier review queue, market management and launch readiness tabs
Admin portal preview. Carrier review, market controls and launch readiness, with sample data.

2. Product and payments: the launch build

Once the checkpoint was in, the platform’s real launch blockers were visible. The launch needed them fixed, so we went beyond the original scope.

  • Six day-one defects fixed.
    • Paid bookings never reached a mover.
    • No mover could accept any job.
    • Receipts showed the estimate instead of the amount charged.
    • Scheduled jobs could never run.
    • A shipper dashboard errored on every visit.
    • Payout setup failed silently.
  • A complete payment lifecycle, verified in Stripe test mode. Book, authorize, dispatch, check in and out, approve hours, settle to the cent, refund. All 52 end-to-end checks passed, on desktop and on phone. This is test-mode verification, not a claim of production payment processing.
  • Junk removal, built in a day to the founder’s eleven-page specification:
    • pricing by the truckload or by the item
    • a disposal set-aside that’s refunded if the dump costs less
    • fees for special items
    • a crew model of one hauler plus helpers
    • dump receipts matched to each job
    • a switch to turn the service on city by city
  • Pay before dispatch on every service.
    • The customer’s card is charged in full at booking.
    • A server-side funding check guards every dispatch and every job start.
    • Extra work is approved and paid for before the crew does it.
    • Unused allowances are refunded at settlement.
    • Every dollar is split between the platform, the helpers and the hauler to the cent.
Junk-removal booking step one: choosing a truckload size, with a live all-in price
Junk booking, step 1. Truckload or items, with the price updating live.
Junk-removal booking step two: the crew and one all-in price paid at booking
Step 2. The crew and one all-in price, paid in full at booking.
Junk-removal booking step three: review and pay before any crew is sent
Step 3. Review and pay. No crew is sent until the payment has gone through.
Junk crew view showing open seats on sample jobs and the pay for each seat
What haulers and helpers see. Open seats, with the pay shown before they accept.

3. Launch pages and the public preview

  • A live launch signup on his domain: two lists, one for customers and one for workers; consent wording, spam protection and rate limiting; and signups written straight into the same database table the full application uses, so every early signup is already in place on launch day.
  • A public click-through preview of all eleven portals with sample data, so investors, partners and early crews could see the product without a login. The preview is separate from the application itself, which sits behind a login and belongs to the client.
  • A working domain. We repaired the broken delegation and pointed the domain at the new hosting, and the launch page went live on day two.
Moving-labor booking: choosing movers and hours, with an itemized live estimate
Moving-labor booking. Sample crew, hours and an itemized live estimate.
TempMovers junk-removal launch page
The junk-removal landing page. The public introduction to the added service.

4. The handover

  • Complete code history. Every branch with its full history, 6 branches and 41 commits, in a single self-contained file, with the checkpoint and the final delivery clearly marked.
  • Restorable backups of the production and staging databases, with per-table counts and restore commands.
  • Written close-out. The website source, plus a close-out that answered his acceptance review point by point.
  • Access record. A timed record of every access we held being removed or handed back.
  • Delivered to the client’s own drive. The platform, the data and the history are his.

The connections

SystemWhat it does for TempMoversWhat we did
PostgreSQL 18 on NeonThe platform’s databaseCreated it for the first time; a branch for each environment; a point-in-time restore drill
PrismaSchema and migrationsGenerated and inspected the first migration; fixed the seed
Next.js 15, React 19, TypeScriptThe application and its eleven portalsRepaired the build, patched the advisories, restored the styling
Stripe (test mode, ready for marketplace payouts)Payments and payoutsAuthorize and capture, paid change orders, refunds, payout split to the cent
VercelHosting and serverless functionsSet up the project, attached the domain, deployed the launch page and the signup function
Domain and DNSThe client’s domainRepaired the broken delegation and pointed it at the new hosting
Neon serverless driverThe signup function’s link to the databaseLaunch signups written straight into production
VitestAutomated tests310 tests grown to 355, all passing, plus 27 permission tests

By the numbers

DeliveryCheckpoint in 5 days; full build and handover in 8
Schema97 tables migrated with 0 destructive statements; 107 tables, 100 enum types and 136 foreign keys after the new features
Build34 type errors → 0 · production build failing → passing
Automated tests310 → 355 passing, plus 27 of 27 permission tests
End-to-end payment checks52 of 52 in Stripe test mode, desktop and phone
Launch defects fixed6, each one a day-one blocker
Critical security advisories patched3
Portal screens restored18
Features addedJunk removal · pay before dispatch · launch signup · eleven-portal public preview
Handover6 branches, 41 commits, production and staging backups, written close-out
Client rating★★★★★ 5.0 on Upwork

Historical delivery outcomes from October 2026, not a claim about the client’s current site.

What the client said

“Clinton at VASRUE Digital Media built out my TempMovers platform: junk removal booking, a launch waitlist, and pay-before-dispatch checkout through Stripe. He tested on a separate copy of the database, never on my live data, and put every step in writing. At closeout he delivered the full code history, three database backups and a clear report on what was done. Organized, thorough, and straight with me about what was and wasn’t finished. I’d work with him again.”

Founder, TempMovers · ★★★★★ 5.0 on Upwork · Endorsed as Clear Communicator and Detail Oriented

Read all of our Upwork client reviews →

How we work

  1. Nothing passes on code review alone. Every claim in the evidence packet has a command, a test run or a database read behind it. When something failed, we wrote it down as a failure.
  2. Prove it on a copy first. Every migration and test ran on a staging copy of the database, and a throwaway copy took the restore drill. The live data was never the test bed.
  3. Build to the document. Each feature was built to the client’s own written specification. When the document changed, the build changed the same day.
  4. Leave nothing hidden. The handover carried the full history, the backups and a timed record of every access we held. The client can pick it up with any developer, anywhere.

Skills used

  • Database engineering: PostgreSQL, Prisma migrations, schema verification, a branch per environment, backup and point-in-time recovery
  • Application engineering: Next.js, React, TypeScript, build repair, dependency security
  • Payments engineering: Stripe authorize-and-capture, refunds, paid change orders, marketplace payout splits
  • Product build: pricing engines, booking flows, crew models, city-by-city service switches
  • Cloud and DevOps: Vercel deployments, serverless functions, DNS and domain repair
  • Quality assurance: automated, permission and end-to-end testing on desktop and phone
  • Technical writing: evidence packets, an operations how-to, close-out and handover reports
  • Client management: scoping before the contract, written status at every step, a clean and documented exit

About the images

Every image is a still of a public page. The launch page and the junk-removal page appear as they were live on 30 October 2026. The click-through preview was shot from the exact files we delivered. The application itself sits behind a login and belongs to the client, so it isn’t shown. The preview pages carry a “sample data, not the live app” banner, which is accurate: sample prices and statistics in the screens are interface examples, not revenue, customers or the development price.

A paid client engagement on Upwork, shown with the client’s public 5-star review. The founder is not named, and the client’s current website is not linked: the site was replaced after handover, so this page uses archived stills instead of live links. Payments were verified in Stripe test mode; no production payment processing, commercial launch, revenue or customer figures are claimed. No credentials, private records or contract terms are shown.

PostgreSQL, Next.js, Stripe, database architecture, data migration, Prisma, TypeScript, payment integration, Vercel, automated testing, launch readiness.

Download the 12-page case study (PDF, 1.5 MB) →    See another platform we built →    More web development work →

Have a platform that’s almost ready to launch?

Databases that were never created, builds that won’t pass, payments that need to work before the first customer does: we scope it with you, prove every step on a copy, and hand back everything in writing.