What we shipped. When we shipped it.

Receiving-session open and resume routes now land operators back in the right intake screen, without the router detour.

Data-bearing assets cannot leave a workflow stage unless they are wiped or destroyed, with shredding and certified recycling treated correctly.

Universal search gained command-palette actions, recents and modes. Market deals now close two-sided and point operators toward invoicing or escrow.

Deal rooms, settlement workspaces, counterparty labels, channel clarity, empty states and realtime copy were remediated. Tenant billing settings landed too.

Pipeline now shows upstream receiving work, receiving sessions can resume, first-run empty states guide setup, and Core CRM actions stopped repeating themselves.

Compliance screens got the plain-spoken pass: risk, evidence, media warnings, gates, and “why can’t I click this?” moments now explain themselves before someone starts a side-channel investigation in Slack. Package enforcement got stricter too. The product is still dry; it is just dry with receipts.

The founder dashboard got velocity charts, PR rules, manual corrections, info buttons, and a multipage PDF export for people who need numbers to sit nicely on paper. ReVend also gained a reusable chart library, cleaner outbound PDF branding, and less package-matrix clutter. Investor-update energy, minus the ritual deck panic.

Saved views stopped pretending. Teams now get starter views in a real tenant-scoped table, can save private or shared filter sets, and each operator pins and defaults their own bar without moving everyone else’s cheese. Asset history and workflow counts also stopped leaning on fake snapshots. Small button, real memory, fewer cardboard props.

Contracts now push workflows, SLAs, erasure gates, and disposition preferences into the actual work. Drivers got mobile routes, stop actions, photos, signatures, GPS stamps, and outbound proof-of-delivery. Storage quotas, sourcing polish, early access capture, and secret-decrypt recovery joined the same day. The clipboard has been asked to consider retirement.

Imports, archive/delete flows, and dispute evidence got safer. The import center landed, audit trails hardened, lifecycle actions now preview dependencies before anything disappears, and dispute evidence is separated by party. You can still do serious admin work; it now arrives with fewer foot-guns in the box.

The user manual and behavior handbook grew into real operating material instead of undocumented folklore. Dashboard, support, roles, workflows, settings, sourcing, escrow, auction, market, and core all got covered, then the translation train started moving. Documentation is still documentation, but at least now it has a map and snacks.

Public API V2 filled out the missing surface, the contract and OpenAPI references caught up, webhook plumbing got tidier, admin invitation resend stopped sulking, and Activity Audit gained a tamper-evident hash chain. Boring words, serious spine. Exactly the kind of release auditors pretend not to enjoy.

Packages are no longer just sales copy. Public pricing now comes from the catalog, ReVend OS knows each tenant's modules, features, and limits, and gates block actions outside the package. Auction deposits, trade-in draft resume, and the beta health check also landed. Fewer promises in slides; more behavior in the product.

Auction sellers can add a buy-now price, and buyers can skip the elbowing match when the number works. One click reserves the lot, starts the deal path, and moves it toward outbound and escrow. For the moments when a bid war sounds fun until finance asks why the server pallet is still sitting there.

ITADs that already run operations elsewhere can now feed sellable stock into ReVend OS via CSV, XLSX, XML, JSON, or API. Assets can be grouped into lots, published to Market or Auction, and tracked back through webhooks when the commercial side moves. Finally, a bridge for teams whose ERP has very strong opinions.

Data-wipe evidence is easier to trust at a glance. Assets now show whether erasure is ready, failed, missing evidence, or waiting on an imported report, with the source document tied to the import. Less hunting through Blancco exports; more “can this device leave the building?”

Document sharing got more grown-up. Customer-visible files are explicit, downloads are logged fail-closed, and admins can open access history per document. Perfect for the classic audit question: “who saw this certificate?” now answered without a group chat archaeology expedition.

The activity log got clearer labels, more sensitive platform work leaves a trail, and feature packages moved into a proper admin matrix. This is the sort of release nobody screenshots, but it is why support can answer “what happened?” without summoning a spreadsheet séance.

A public REST API and webhooks landed. Your other systems can now ask the platform questions about orders, documents, and assets — and the platform yells back when something interesting happens. Retries with backoff, a test-webhook button, a failure inbox in the UI. The era of CSV-by-email is officially over, and everyone is allowed to be a little sad about that.

Search engines can read us now. Per-page metadata, structured breadcrumbs, a sitemap and robots.txt that actually serve, and the marketing site speaks all four languages with the right canonical URLs. Login screens, account-closed/suspended/maintenance pages, and the cookie banner finally remember which language you picked. Plus quiet plumbing: visitor analytics with IP-to-company resolution — so we know which prospect bounced off which page without making them fill out a form to confess it.

The app speaks Dutch, French, and German now, on top of English. Every screen an operator, customer, buyer, or admin will ever land on — from the dashboard down to the cookie banner on the marketing site — got translated and wired up. Pick your language in the header; the rest of the platform follows you home. On the security side, a quiet round of browser-header tightening — the kind nobody notices until a penetration tester does, at which point everyone does. Roughly two thousand translated strings shipped this week, which we hope you never have to count.

Two-factor authentication is live. Operators enroll an authenticator app, verify once, and find the controls in settings — about time, given the previous defense was a password and a hopeful expression. Underneath, the first wave of a security sweep closed nine items: login redirects that trusted strangers, gates that let the wrong role through, and the bits of the platform that took the URL bar a little too literally. Audit logging is now wall-to-wall — every meaningful change a tenant makes leaves a trace. Helpful when somebody asks why something happened. Very helpful when somebody insists it didn’t.

A heavy features day. The app stopped forgetting where you were — click into a deal, click back, and the same tab and the same filter are waiting for you, instead of resetting to the top like a goldfish. A public REST API landed, with webhooks your team configures itself, so your other tools can talk to the platform without anyone scraping a screen. Customer-visible documents now require an explicit share — nothing leaks by accident. The audit log covers every place where data actually changes — if it moved, it’s recorded. And auction bidding learned to survive the moment offers really do pour in fast, because a bid that quietly vanishes is a customer who quietly leaves.

Five fixes for dashboards that were quietly lying. Revenue figures stopped including money that hadn’t actually arrived. SLA clocks stopped counting weekends as if the warehouse ran a Saturday shift, and now pause when a request is waiting on the customer. Every widget grew an info icon that explains what it measures. Alert thresholds went per-tenant — five thousand assets a month is not the same job as fifty. And changing a threshold now asks for a reason and a review date, because a number that pages someone at 2am deserves a decision, not a click.

A long maintenance day, and none of it shows on a screenshot. Notification emails stopped sending twice when something hiccupped mid-send. Stuck digest emails give up after fourteen days instead of retrying the same dead address forever. Retiring an asset writes the reason back into the audit trail, where R2v3 expects to find it. Two of the slowest dashboards got their answer in one shot instead of grinding through hundreds of rows. And the warehouse team can no longer wander onto the Escrow, Auction, Market, or Sourcing pages — those are properly gated by role now.

New tenants used to find their way around by clicking everything until something happened. Now an onboarding tour walks them through it. The hub tour covers the dashboard widgets and where the modules live; nine deeper tours pick up where the hub leaves off — Core, Market, Auction, Escrow, Trade-In, Sourcing, Compliance, Admin, Settings — each one dismissible, resumable from a quiet compass icon in the header, and auto-prompted exactly once. Sourcing got a smaller addition that bidders will notice: the compliance and security requirements a request demands now show inline on bid detail, so you see what the customer actually wants before pricing it.

Trade-in intake grew up. Each device in a pickup request now gets its own row — manufacturer, model, condition, serials, and whether the drive has data on it — because “340 mixed laptops” is not a manifest, it’s a guess. Two new intake steps capture compliance and security requirements before a request goes live, backed by a seeded catalog of service codes that means “certified erasure” resolves to the same thing whichever ITAD reads it. Disposition preferences now travel through the request lifecycle so the awarded ITAD knows upfront what you want done with what they cannot resell.

A long polish weekend across the trade-in module. Customer-visible invoices finally render something a finance team can read. Awarded ITAD identity reveals to the customer at award time, with a one-click clone into the ITAD’s CRM so the relationship starts in the right database. Pickup-request intake got richer — manufacturer, model, specs, serials per device — on a wizard that lets you correct grades on the fly. Operator dashboards consolidated their widgets into role-tuned presets so warehouse and finance stop staring at each other’s KPIs. And admin support gained trade-in account impersonation as a proper detail page with audit, plus a corporate funnel that finally calls the corporate accounts what they are.

Web manifest landed and the app got a proper icon. Install to the home screen on a warehouse tablet and it opens like an app, not a Chrome bookmark with the address bar wasting fifty pixels at the top. Small win, big difference at the receiving dock when the operator’s left hand is on a scanner and there’s no time to fumble through tabs.

A docking station shipped with the laptop. Two SFP transceivers came with the switch. Eight RAM modules came out of one server. The dock is not a separate thing on the inbound list — it is part of the laptop, and treating it otherwise loses the relationship the moment somebody sells the laptop without remembering the dock. Now the data model knows. Parent-child relations on assets, with a picker that won’t let you create cycles, and a history that walks the family tree both ways.

Mollie payment primitives landed and got wired into the trade-in award flow. The platform now actually moves money, not just records that money should have moved. Trade-in billing settings got their own page so each tenant can configure where their euros land. The first transaction the platform processes is going to feel like a small ceremony.

An entirely new module shipped over a long weekend in milestones M0 through M5. A customer publishes a pickup request from a portal that has its own auth, RLS, and shell — separate from the operator app where it should be. Tenants discover the request through Coverage config and bid with a variant-pricing form. The operator awards, a fee ledger settles, both sides see a comparison view. Pickup events flow through the existing notifications pipeline. Customer-side: invite flow with domain verification and signup auto-link, approval workflow, document access with a certificate viewer, notification preferences, bid revision history. Smart relaxation suggestions for zero-bid requests, because a customer who sees crickets leaves and doesn’t come back. Mobile carousel for bid comparison and camera upload for location photos, because half of these requests get filed from a phone next to the kit.

When a tenant gets stuck — escrow won’t release, signup never sent the verification email, subscription_status drifted from reality — platform staff used to need a SQL console and a careful hand. Now there are buttons. Three escape-hatches for stuck escrows. Force-completer endpoints with UI for stuck operational flows. Manual per-tenant Blancco sync trigger. Email-verification controls and stranded-signup recovery. Direct subscription_status override. audit_events became append-only at the trigger level — no more rewriting history. Impersonation with session-tracking and a middleware-level write-block on mutating methods, so support can investigate without accidentally posting as the customer. And a first-login welcome tour with driver.js, because new tenants shouldn’t need a Loom video to find Inventory.

Per-order service fees with proper residual rounding. A round2 utility standardised money rounding across thirty-odd places that were each rounding their own way slightly. Vitest with property-based tests for fee and settlement calculation, because “looks right” and “reconciles to the cent” are different things. The escrow cron writes settlement rows before flipping status, and raises on missing config instead of silently doing nothing. Atomic per-tenant asset_tag allocation via RPC closes the race where two simultaneous receives both tried to grab tag #481. GDPR Article 20 account export, plus a hardened Article 17 delete. And subscription limits got teeth — soft-block when tenants exceed plan, instead of finding out at month-end.

Dashboards stopped re-fetching everything on every nav. Receiving got a trigger-maintained counter instead of recounting items on every page load. Blancco sync batches inserts and parallelises asset updates. Evidence-zip batches DB queries and chunks storage downloads in parallel. The unread-bell counter got a user-aware partial index, because checking the bell shouldn’t scan the whole notifications table. Postgres-backed rate limiting via rate_limit_check RPC across public and authenticated mutations, in three tiers — no external Upstash dependency. And the Blancco parser stops politely when somebody uploads a 200MB XML, instead of OOM-ing the worker.

A long-overdue security pass. Seventy-three SECURITY DEFINER functions had their callers locked down. RLS policies consolidated, audit_events INSERT locked down, search_path pinned on fourteen functions. MFA TOTP enabled on auth. Defense-in-depth tenant_id filters on report read paths. Atomic bulk-receive via Postgres RPC, instead of an N+1 INSERT loop with a half-honest transaction boundary. Centralised storage governance with per-asset-class signed-URL TTLs. Cron auth fails closed when CRON_SECRET isn’t set. Auth-flow gaps closed in password-reset, email-verification, and account-deletion. Immutable asset chain-of-custody trail. Bumped to Next 16.2.4.

Escrow deposit confirmation now requires two owners: one proposes, the second approves. The kind of control auditors look for and finance teams sleep better knowing exists. Platform settings consolidated into one parser library so admin, security, maintenance, and analytics don’t each reinvent how to read the same JSON. Deferred-data route handlers slim heavy SSR pages and load secondary panels on the client. Drivers grew up: email is optional now (warehouse crew often don’t have a work address), “inactive” replaces hard delete so history sticks to the vehicle assignments, and a license-categories sub-page lets each tenant manage codes for their own jurisdiction.

Admin activity finally loads cleanly — single load path with abort, retry on errors, sort by actual event time instead of by “whatever the API returned in.” Strike pardon got an explicit busy state and readable toasts when something fails. The password policy API returns the merged tenant policy when there’s a session, so the hint on a tenant’s account page actually matches what their tenant configured — and not the platform default that has been quietly diverging.

Bulk-receive landed on the inbound-detail manifest tab, instead of needing the operator to scan one item at a time on a tablet that has the patience of a teenager. Pickups can now be multi-trip — three trucks for one collection, no more pretending it all fits in one. Tenant-configurable numbering for asset tags, orders, and shipments, because every tenant has their own scheme and forcing R-001 onto a company that wants OPS/2026/00481 was a losing battle. window.prompt and window.confirm replaced with proper dialogs across sixteen callsites — because nothing says “professional ITAD platform” like a 1995 native browser prompt.

Place bid and Watch buttons stopped being decorative. Watcher notifications fan out for new bids and ending-soon, with a 24-hour reminder alongside the existing 1-hour one — for the bidders who set an alarm and the ones who didn’t. Non-escrow disputes get the same trust-attribution path as the escrow ones, so a complaint outside the escrow flow stops being a forwarded email thread that nobody can find a week later. And the buyer-side dispute path that used to dead-end now actually opens a complaint.

Blancco wipe certificates can now be ingested per asset (PDF, XML, or CSV), batch-imported with a match preview before anything writes, or pulled live via the Blancco API on an hourly Vercel Cron. Unmatched certs land in a review queue instead of getting silently dropped on the floor — somebody has eyes on every cert that didn’t auto-match. ESG dashboards got a proper PDF export with a client certificate and a one-click email send, because audit week is not the time to be assembling PDFs by hand from screenshots.

Three buttons stopped lying. Edit Asset on inventory now opens five per-section dialogs — identity, specs, status, location, lifecycle — each with audit-trail. New Invoice has a real services + credit-note flow with audit, instead of the placeholder that smiled and did nothing. And Make-offer on the listing detail goes through a market audit-trail instead of vanishing into a void where nobody could later answer “what did we offer them three weeks ago?”

Escrow grew teeth. Buyers wire to a held account, sellers ship when funds are visibly held, the platform auto-releases when the inspection clock runs out. Disputes get a structured form with the original grading and inspection report on screen, instead of a forwarded email thread where nobody can find what was actually agreed. Trust scores stopped pretending: cert verification flips the score in real time, response-time joins as a fifth dimension, and rapid-bid bursts trip platform-tunable thresholds — three escrow-deposit timeouts in 180 days auto-blocklists the bidder. Demanufacturing got a real flow with a sellable-quality gate. And the scanner picked up Code128 on rack labels with a camera fallback for Safari and Firefox, so the receiving-dock tablet keeps working when the browser refuses to play.

Ten core pages traded their mismatched outfits for the house uniform: same buttons, same tables, two colours, one product. Pallets got a proper home with move, merge, and split actions that talk to the database instead of pretending to. Carriers stopped being a dropdown pointing at nothing — pick one from your catalogue and it follows the shipment through to the collection. Watchlists, trust scores, cycle counts, governance, parts — all left the mock drawer and joined the database. And inventory grew a saved-views bar, because “the filters I set yesterday” should not need setting again today.

About 1,800 lines of dead mock data quietly packed up and left. Four settings pages — catalog, shipping, integrations, and the public collection-request form — got the proper two-colour rebuild nobody was asking for but everybody needed. Sixteen query modules stopped routing around the type system and started talking to Postgres in proper sentences. The “mock” fault-code catalog turned out not to be mock at all — it was the platform’s stock catalog all along, so we renamed it to what it always was. The app is now measurably less likely to explode on a Tuesday.

The market inventory page stopped trying your patience. Every row now shows whether it’s Available, Draft, Published, or Sold — so you stop opening three tabs to find out. Quick filter pills across the top, each with a live count: click "Published" to see only what’s live, click "Sold" to see only what’s gone. Tick a dozen rows and archive them in one go. Every item gets tags and private notes — the sort of thing your trader writes to himself at 2am: “hold for Gregor, he’ll take all of these at list price.” And when the warehouse re-grades a laptop from C to B, one button brings that update through without touching your price or your notes.

Two small things, both overdue. Inventory rows and detail pages now show a stale warning badge when a listing has been sitting too long without movement — the kind of nudge that used to live on a sticky note behind somebody’s monitor. And photos on asset detail got a proper lightbox, because opening an image in a new browser tab just to see it larger than a postage stamp was a 2014 move.

The app learned to tell you things. Messages in deal rooms arrive without anyone hitting refresh. A bell in the top bar with a proper notifications center so you can see what you missed while you were at lunch. Pings for the things that actually matter — new offer, new message, auction closing, stale inventory — with a preferences page where you pick what’s worth interrupting you for. And a morning email digest that rolls twelve notifications about the same deal into one readable summary, because twelve notifications about the same deal is twelve too many.

Auctions grew up. Publish a lot, browse lots, place bids, watch the timer do what timers do. And when an auction ends, the machinery quietly does what used to need a human on Monday morning — picks the winner, settles the payment, transfers the inventory to the buyer, closes the lot. No more “wait, did that auction actually close?” There’s a winner, there’s a settlement, there’s a record that says it happened.

Market used to be a pretty demo. Fictional data, zero consequences. It is now real. A four-step wizard for building a batch, so you never end up with half a batch published at 2am. A rebuilt deal room that tells you exactly what the next action is. Cross-tenant browsing, so you can actually see what other sellers have listed. A counter-offer flow that stops pretending a price is final when both sides know it isn’t. And the platform quietly suggests matches between buy and sell intents, so you stop casting nets into the void.

Not every laptop in your warehouse is ready to sell. Some are being tested, some are contractually blocked, some look cosmetically dubious and somebody should really take another photo. The app didn’t have a word for the ones that ARE ready — until now. Sellable items live on their own shelf, each with a quality score, plus a home for the non-core stuff (spares, accessories, the networking gear that wandered in from last month’s decommissioning). Import from a CSV with a proper wizard. Upload photos and documents per item. Set a stale threshold and anything sitting too long quietly drops off the market, because nothing kills a marketplace faster than a listing for a laptop somebody already took home in February.

Photos used to be the problem nobody solved. Taken on your phone, emailed to yourself, attached to a thread that vanished in October — and three weeks later somebody asks if this Dell had a dented corner when it arrived, and there’s no answer. Now: every asset has a photos tab. You snap them with your phone by scanning a QR code. Thumbnails appear as fast as you upload. And a warehouse-wide library lets you browse everything without clicking through twelve assets to get there. “Defect Exports” became “Evidence Packages,” because nobody files a defect export — they file an evidence package. Meanwhile the design system dropped to two colours. Twelve shades of meaning turned into two. Nobody misses the purple.

The old dashboard showed six numbers to everyone and assumed the warehouse team and the CFO wanted to see the same six. They didn’t. Now there are forty-seven widgets, five role-based presets (Warehouse Ops, Sales, Finance, Admin, Executive), and a grid you can drag things around on. Pick a preset, throw out what you don’t need, add what you do, save it, make a second one, switch between them like browser tabs.

Receiving used to be a vibe. You clicked "start," scanned things until it felt done, and then the pallet existed in the system without anyone being entirely sure what was on it. Now it’s a proper session — with a beginning, an end, and a signed handoff that says "these assets are now inventory, stop asking." No more Schrödinger’s pallets. The receiving list stopped showing orders that aren’t receiving anything (drafts, cancellations, three-weeks-ago) and the progress column stopped insulting you with "0/0" when there’s nothing to count. The warehouses page, which used to crash every time you visited, now works — which is what pages are supposed to do.

Collections finally work end to end. Schedule a pickup at your client's office, confirm the date, assign a driver, track it through to delivery — and when the truck arrives at your warehouse, the system creates an inbound order automatically with everything filled in. No retyping the client name, no copy-pasting the contract reference. Open any contract and you can see exactly which collections and inbound orders belong to it, instead of switching between three screens to piece that together. Six more pages across the platform — inbound orders, receiving, outbound, settlements, and invoices — got cleaner tables with search, filters, and a consistent look that makes the whole app feel like one product instead of twelve prototypes stitched together.

The contract detail page used to show the same information in three places and call it thoroughness. Now the header says the contract name and nothing else. Services are in a simple table instead of decorated cards that looked nice but slowed you down. Pricing, SLA terms, and renewal details each have their own section that you can scan in two seconds. Editing a lease contract happens right on the page — fourteen fields without opening a single dialog. The admin pages for users and activity logs load in one shot instead of making you wait while they fetch data four times in a row.

Your warehouses finally have a proper address book. Zones and racks used to be stuffed inside each warehouse record as one big blob — impossible to reference, impossible to search. Now every zone, every rack, and every zone type is its own thing. A new Locations settings page lets you draw your floor plan: add warehouses, nest zones inside them, stick racks inside those. Also, the activity log stopped lying — it used to claim you changed nine settings when you only touched one.

Contracts grew up. Create one from scratch with a company, services, pricing model, and certifications — all in one form. Edit everything inline. Manage services through a dialog where you click to add and never touch a submit button. Terminate with a modal that asks why. Company certifications stopped being fake. And a new two-color badge rule means the entire UI finally agrees on what colors mean.

Twenty-four certifications that matter in ITAD — from R2v3 to B Corp — now live as a proper catalog. Each with its issuing body, scope, and renewal period, so you stop googling "what does NAID AAA require" every time a client asks. Toggle what your org cares about, add custom certs for the niche ones nobody else has heard of.

Documents got a home. Upload a PDF, tag it, link it to a company, find it again three months later without digging through email. Every linked document shows up on the company’s detail page. Tags went universal — one system for contacts, companies, and documents instead of three separate ones pretending they weren’t the same thing.

Currency went from a hardcoded dropdown to 147 real currencies with live exchange rates that refresh every morning. One formatting function replaced thirty-four copies of the same code doing the same thing slightly differently. The Languages settings page was removed because scrolling through a hundred languages to find Dutch is not a user experience.

The app learned to remember how you like your dates. Pick DD/MM/YYYY, MM/DD/YYYY, or YYYY-MM-DD and every page follows. Custom services can now be deleted while platform defaults stay protected. Floating bottom bars that covered your content got replaced with buttons that stay where they belong.

Thirty-five ITAD services across seven categories, each with a short code and a default rate. Drag to reorder, toggle to deactivate, get warned when you’re about to break a dependency. The kind of configuration page that saves you from looking up the same numbers every time you write a contract.

The platform learned to manage itself. Organization profiles with real business fields. User management where you can suspend people but not yourself. An activity log that records everything. Five demo customers with real addresses so the overview page finally shows actual numbers.

The app finally learned who owns what. Organizations, memberships, and a tenant system that lets colleagues share a workspace instead of staring at blank screens. Seven roles instead of four, because your warehouse team doesn’t need to see deal negotiations. Every page got an ID number. And 761 lint problems got cleaned out like a garage avoided since January.

Companies and Contacts got their final look. Rebuilt from scratch with cleaner layouts, consistent patterns, and the kind of attention to detail that makes you stop noticing the UI. For the first time, the CRM feels like it was designed, not assembled.

Every contact and company can now have notes. A proper communication log instead of the sticky note on your monitor that fell behind the desk in 2024. Six social media fields landed on contacts because your suppliers exist on LinkedIn and your buyers negotiate on WhatsApp.

The marketing site went from functional to something you’d actually send to a prospect. Thirty blog articles with titles like “Grade B Is Not a Grade.” Every page rewritten with actual personality. Plus a 404 page that checks Rack A3 for your missing URL.

The mock data era ended. Every remaining Core entity moved to a real database. Settlements calculate themselves from contract pricing. Invoices handle VAT and credit notes. The old mock files still exist in the codebase like furniture in a house nobody lives in anymore.

The features that turn a collection of modules into a complete product. Barcode scanning with five modes, a cross-module analytics dashboard, and the API blueprint — endpoint catalogue, key-management UI, webhook subscription concepts. Public endpoints follow with the launch package.

Two modules in one session. Auctions got four formats with anti-sniping protection and a simulation page where you can watch the timer panic. Escrow became its own module with seven steps from “deal agreed” to “money in the bank.”

The Market module went from idea to eleven features. Batch builder, deal rooms with color-coded negotiations, intent matching, trust scores, and seller analytics.

The asset table moved to a real database. Two hundred assets with full specs, grading, and erasure records. Five pages stopped pretending and started querying.

Quality control with inspection checklists. ESG dashboards showing CO₂ saved per recycled device. Lease return management for when your client wants their laptops back and you need to prove what happened to them.

Fleet management for tracking collections across vehicles and routes. Demanufacturing workflows for when devices need to be taken apart, not just wiped. Integration settings for the systems you already use.

R2 and e-Stewards compliance dashboards with audit readiness scores. The first version of cross-module collaboration: shared notes, activity feeds, and the structure that the authenticated client portal will eventually plug into.

Settlements that auto-calculate from contract pricing and grading results. Revenue share splits. Chargeback tracking. The kind of math that used to live in someone’s head and a spreadsheet.

Multi-warehouse management with zones, racks, positions, and pallets. Drag-and-drop rack layouts. Capacity tracking. The physical reality of an ITAD warehouse, digitized.

Major UI overhaul. The sidebar got organized into five modules: Core, Market, Auction, Escrow, Admin. The navigation finally stopped arguing with itself.

Contract management with six pricing models. Because “standard pricing” doesn’t exist when one client pays per unit, another pays per kilo, and a third insists on a revenue share.

Authentication. Login. Signup. Protected routes. The part where we stopped letting anyone with a URL see everything.

Design system cleanup. Consistent spacing, typography, and component patterns across every page. The kind of work nobody notices until it’s missing.

The marketing website got its personality. About page, pricing page, changelog. Copy that sounds like it was written by someone who’s actually been in a warehouse.

Moved from Pages Router to App Router. Rewired everything. Nothing visible changed. The kind of refactoring that produces zero screenshots for the investor deck.

Code cleanup, dependency updates, and the removal of things that seemed like good ideas at 2am but weren’t. Technical debt paid early.

Testing and diagnostics queue with priority levels and tester assignment. Inbound order processing with device scanning. The conveyor belt started moving.

First warehouse views. Asset list, asset detail pages, basic grading forms. The skeleton of what would eventually become Core. Looked terrible. Worked correctly.

Dashboard layout, sidebar navigation, dark mode. The absolute minimum needed to show someone what this could become without them laughing.

npx create-next-app on Christmas Day. First commit. First hero section. First rewrite of the hero section (the next morning). Some things never change.