In this article
A founder running a growing marketplace recently told us their Stripe integration was “basically done” after two weeks. The payments worked. Customers checked out, sellers got paid, refunds processed cleanly. What wasn’t done, what’s rarely done at that stage, was the layer underneath: sales tax obligations that kick in once a seller crosses certain revenue thresholds in a given state, 1099-K reporting duties tied to total payment volume, and an audit trail that holds up if a state tax authority or a payment processor asks questions a year later.
That gap between “payments work” and “payments are compliant” is where most US software projects run into trouble. None of it is exotic. All of it is buildable. It just has to be planned before the first database table gets created, not patched in after a state sends a notice.
Nexus isn’t a feature flag, it’s a data model problem
For decades, a business only owed sales tax in states where it had a physical presence: a warehouse, an office, an employee. That changed on June 21, 2018, when the US Supreme Court ruled in South Dakota v. Wayfair, Inc. that states could require out-of-state sellers to collect sales tax based on economic activity alone. South Dakota’s law at the time set the bar at $100,000 in sales or 200 transactions into the state per year, and most states that followed copied some version of that number.
“Most” isn’t “all.” Organizations that track state tax law, such as the Tax Foundation, note that several states have since dropped the 200-transaction count and kept only the dollar threshold, and the dollar figures themselves range from $100,000 up to $500,000 depending on the state. None of this is advice for any specific business: thresholds change, and a state’s department of revenue is the only reliable source for a current number. For a developer, the practical takeaway is narrower: nexus has to live in your data model as a per-state, per-year rolling total, not as a single global switch that says “we collect tax” or “we don’t.”
That means tracking, at minimum:
- cumulative sales and transaction count by state and by calendar year;
- the date each threshold was crossed, since registration and collection obligations typically start going forward, not retroactively;
- which entity in a multi-seller platform is responsible for collection, the platform itself, under marketplace facilitator laws now active in nearly every state with a sales tax, or the individual seller.
Most teams don’t build a tax calculation engine from scratch. They wire into one. Avalara and TaxJar are the two most established options for mid-size and larger platforms, with rate calculation, filing, and nexus-tracking built in. Stripe Tax is the common choice for teams already on Stripe for payments, since it reads directly off existing transaction data and needs less separate data plumbing. The table below is a rough comparison, not a buying guide, since pricing models and thresholds shift, so check current docs before committing.
| Tool | Best fit | What it handles | Integration effort |
|---|---|---|---|
Avalara |
Mid-market and multi-channel sellers |
Rate calculation, nexus tracking, filing in most states |
Moderate, dedicated API, usually a multi-week integration |
TaxJar |
Smaller platforms and marketplaces |
Rate calculation, reporting, some automated filing |
Lower, well-documented REST API |
Stripe Tax |
Teams already processing through Stripe |
Rate calculation tied to existing charges |
Lowest, minimal extra data modeling if Stripe is already the payment layer |
What a platform actually owes the IRS: Form 1099-K
If your platform moves money between third parties, a marketplace, a gig-work app, a rental booking tool, you’re likely a “third-party settlement organization” under IRS rules, which means you owe sellers and the IRS a Form 1099-K once their payment volume crosses a reporting threshold.
That threshold has been a moving target. The American Rescue Plan Act of 2021 set it permanently at $600, replacing the older $20,000-and-200-transactions rule. The IRS delayed full implementation more than once. IRS Notice 2023-74, issued in late 2023, set a transition threshold of $5,000 for tax year 2024 and signaled further step-downs in later years. Congress and the IRS have both revisited this schedule since, so the number for any given tax year should be confirmed directly on IRS.gov before a filing season starts, not assumed from an article written months earlier.
The engineering lesson is more durable than the number itself: hardcoding a reporting threshold into application logic is a mistake you’ll regret the first time the IRS adjusts it. Store it as a configurable value, version it by tax year, and build the reporting job so finance or ops can update the figure without a code deploy. We’ve seen the same pattern cause pain in financial reporting systems outside the tax context: in an ERP project we built for a transportation company, operational KPIs and driver compensation rules were originally scattered across spreadsheets, a legacy accounting system, and messaging apps, and every rate change meant manually updating several places at once. Consolidating those rules into one system, with roles and permissions controlling who could change what, cut the sync errors that come from “someone forgot to update the other spreadsheet.” The same principle applies to a 1099-K threshold: one source of truth, one place to update it, logged every time it changes.
Payment reconciliation: where the audit trail actually lives
Tax reporting is only as good as the ledger underneath it. If a platform processes payments through ACH, Same Day ACH, and card rails via Stripe, each of those payment types has a different settlement timeline, a different dispute window, and a different failure mode. Building for compliance means the backend needs:
- a transaction log that records bank authorization status separately from settlement status, since a payment can be authorized and still fail to settle days later;
- reconciliation logic that matches what the payment processor reports against what your own ledger expects, flagging mismatches instead of silently absorbing them;
- a refunds-and-disputes workflow with its own audit trail, since a chargeback reverses a transaction that may already have been counted toward a 1099-K total or a sales tax filing;
- logs that are retained, not just generated, since most disputes and audits look back months, not days.
This is the part of a build that looks unglamorous next to checkout UI, and it’s the part that determines whether a platform survives its first serious payment dispute or state inquiry intact. In a web portal we built for a pawn-lending business, the trickiest requirement wasn’t the catalog or the client dashboard. It was making sure every payment and every signed document carried legal weight on its own, with a digital signature flow and a record of exactly when a client confirmed each transaction. Once that audit layer existed, the payment integration and the operator-facing dashboard built on top of it cleanly, because every transaction already had a verifiable record attached.
Layering in privacy obligations
A platform handling payments and tax data is, by definition, handling personal data too: names, addresses, Social Security or tax ID numbers for 1099-K filings, bank account details. There’s no single federal privacy law covering all of this in the US. California’s CCPA, as amended and expanded by the CPRA, is the one most platforms end up building toward first, enforced by the California Privacy Protection Agency, the state agency created under Proposition 24 specifically to oversee it. Other states have since passed their own versions with different thresholds and different rights, which is why most platforms end up with a state-by-state compliance layer rather than one fixed ruleset.
Practically, that layer includes a consent and preference center, support for Global Privacy Control as a recognized opt-out signal, a deletion-and-access request workflow that can actually locate a person’s data across systems, and a data map that tells your team where tax and payment records actually live. None of this replaces legal advice on which state laws apply to a specific business. It’s the engineering groundwork that makes compliance possible once the legal scope is defined.
Picking the accounting backbone: QuickBooks, NetSuite, or both
Most small platforms end up syncing to QuickBooks because that’s where their customers already keep their books, and QuickBooks’ API is the most commonly integrated accounting system among small-business software vendors, even if exact market-share figures vary by source and shouldn’t be treated as precise. Mid-market platforms with more complex multi-entity or multi-currency needs tend to graduate to NetSuite, which has a steeper integration curve but handles that complexity natively. HubSpot sits in a different lane entirely: it’s the CRM and go-to-market system many platforms connect to for lead and customer data, not a financial system, but it often needs to share customer records with whatever accounting integration handles the money side.
| System | Typical user | Role in a compliance build |
|---|---|---|
QuickBooks |
Small businesses, solo sellers on a marketplace |
Default sync target for invoices, payments, and 1099 data |
NetSuite |
Mid-market and multi-entity businesses |
Handles complex consolidation; steeper, slower integration |
HubSpot |
Sales and marketing teams |
Customer and lead data, not financial records, but often needs a clean handoff to whichever system does the accounting |
Disclosure rules if your platform shows reviews or case studies
Marketplaces and SaaS platforms that display customer reviews, comparison pages, or affiliate links carry their own compliance obligation, separate from tax and payments: the FTC’s endorsement guides require clear disclosure when a review is incentivized, when a comparison page has a financial relationship with a product it’s promoting, or when a link pays a commission. Fabricating a testimonial or publishing a case study based on a relationship that isn’t disclosed is a real enforcement risk: the FTC has brought cases over exactly this. If your platform’s roadmap includes a reviews or affiliate feature, build the disclosure label into the content model from the start, not as a copy edit after legal flags it.
What this costs to build
None of the pieces above are large on their own: a tax engine integration, a reconciliation job, a privacy workflow. Together, they’re usually the difference between a two-month build and a four-month one, and skipping them rarely saves time; it just moves the cost to the week a state notice arrives. At Pazl, fixed-price builds for this kind of work typically start around $3,250–$6,500 (≈£2,600–5,100) for the first phase, scoped after we’ve gone through exactly which states, payment rails, and reporting obligations apply to your business. Every project ships with a six-month warranty on what we build, so a bug found after launch doesn’t turn into a separate invoice.
Frequently asked questions
Do we need to register for sales tax before we have any customers in a state, or only after we cross a threshold? Generally only after you cross that state’s economic nexus threshold, but the clock on registration and collection usually starts from the date you cross it, not retroactively. Track the running totals per state from day one so you’re not reconstructing sales history under deadline pressure.
Can we just use Stripe Tax and skip a dedicated sales tax engine? For many smaller platforms already built on Stripe, yes, since it reads off existing transaction data and avoids a second integration. Platforms with multi-channel sales (in-store plus online) or more complex filing needs usually outgrow it and move to Avalara or TaxJar.
What happens if we hardcode the 1099-K threshold and the IRS changes it again? You’ll need a code deploy mid-filing-season to fix it, which is exactly the scenario a configurable, versioned threshold value avoids. Build it as data your finance team can update, not a constant in the codebase.
How much of this can launch without a lawyer involved? The engineering groundwork, data models, audit logs, consent workflows, configurable thresholds, can be built ahead of legal review. The scope decisions, like which states you have nexus in or which privacy laws apply, need a tax or privacy attorney’s sign-off before launch, not after.
Does Pazl handle the tax and legal filing side, or just the software? We build the software: the data models, integrations, reconciliation logic, and audit trails described above. Filing itself goes through your accountant or a service like Avalara or TaxJar once the engineering is in place.
If your platform is heading toward payments, multi-state sales, or 1099-K reporting and you want the compliance layer scoped before you start building, reach out at hello@pazl.ai.



