I'm Marco Lopez, CMO at NovoEX. I spend a lot of my week talking with developers who contract for teams in other countries, and one point of friction comes up again and again. It isn't the code, the scope or the deadline. It's the moment after the invoice, when the money has to find its way home.
So this post is a practical one. I'll mention what we built at NovoEX in a short section at the end, but everything before that applies no matter where you bank.
Your payment details are an interface
Here's the mental model I keep coming back to. The bank details you paste into an invoice are a public interface. Your client's finance team is the consumer of that interface, and they integrate with it once, store it in their vendor system, and then call it every month.
Like any interface, it works well when it's stable, well documented and predictable. It breaks when the contract changes without notice or when the input doesn't match what the other side validates against.
Thinking about it this way explains most of the payment problems freelancers run into.
The three rails you'll actually meet
You don't need deep banking knowledge. You just need to know which "protocol" each client speaks.
- SEPA for EUR. For a client inside the euro area, paying a SEPA IBAN feels like paying a local supplier. It's the path of least resistance for them.
- SWIFT for GBP and USD. The global wire network. It connects almost everywhere, though a payment can hop through intermediary banks on the way.
- Fedwire for USD. The domestic wire system in the United States. Many US finance teams find a domestic wire simpler to approve than an international one.
When your details match the rail the client already uses every day, you remove a whole category of questions from their approval workflow.
Why the name on the account is your primary key
In a database, the primary key is the thing everything else hangs on. In payments, that role is played by the beneficiary name.
Some providers hand out details that sit on a shared, pooled account, with a reference code that routes the money to you. That can work, but it's a bit like relying on a lookup table someone else maintains. The name the client sees isn't yours, so:
- An accounts payable team may pause a transfer because the beneficiary doesn't match the vendor they onboarded.
- Marketplaces and platforms that pay you out often expect the receiving account to carry the same name as your verified profile.
- Reconciling incoming money becomes detective work, because every payment arrives under a name that isn't yours.
An IBAN in your own name keeps the key consistent across the invoice, the client's vendor record and your account. Consistency is boring, and boring is exactly what you want from money.
Holding currencies versus converting on arrival
Converting everything to your home currency the moment it lands is a perfectly valid choice. Holding balances in several currencies starts to make sense when one of these is true for you:
- You have costs in the same currency. Cloud bills, domain renewals or a subcontractor you pay in euros. Keeping the currency spares you a pointless double conversion.
- You want control over timing. Rather than accepting whatever conversion applies at the moment of arrival, you decide when to convert.
- You like clean ledgers. One balance per currency maps neatly to one stream of client income, which makes tax season less painful.
If you get paid once a quarter in a single foreign currency and spend everything locally, you probably don't need any of this. Simple beats clever when the clever part never gets used.
A pre flight checklist before the first invoice
I treat this like a deploy checklist. Run it once per new client.
- Ask which rail they prefer. One short question before the first invoice saves days of confusion later.
- Send the right fields for that rail. IBAN plus BIC when the money travels by SEPA or SWIFT, and US routing information when a client prefers a domestic wire. Don't send everything and hope they pick the right one.
- Copy your beneficiary name exactly. Same spelling, same order, same legal form as on your account.
- Put the invoice number in the reference. It turns reconciliation into a simple search.
- Agree on who covers wire charges. On SWIFT payments, settle this up front so a short payment doesn't turn into an awkward thread.
- Start with a small first transfer. For a new client and a large contract, a small test payment confirms the integration works before real volume flows through it.
- Version your details. If you ever change accounts, tell every client in writing and ask them to confirm the update in their vendor system.
Bugs I see in the wild
- Stale config. A client keeps paying old details from a vendor record nobody updated.
- Wrong caller. A payment arrives from a parent company or a different entity than the one you invoiced, and now your records don't line up.
- Round trips. Automatic conversion on every incoming payment, followed by conversion back to pay a bill in the very same currency.
- Missing logs. No contract or invoice saved next to a large incoming payment, so a simple question about where funds came from takes a week to answer.
Keep a folder per client with the contract, every invoice and every payment confirmation. It's the equivalent of good logging: you rarely need it, but when you do, you really do.
Where NovoEX fits
This is the part where I'm biased. At NovoEX we offer an Instant IBAN in your own name. Euro clients can pay you over SEPA, sterling and dollar payments can arrive by SWIFT, and US clients can also use Fedwire, all into a single account, and keep crypto alongside your fiat balances if you work with both. KYC is required, and the account is always in your own name. Virtual cards are coming soon, and so are third party payments.
If that matches your invoicing setup, you can Open an account.
Whatever provider you choose, the principle stays the same: make your payment details a stable, predictable interface, and your clients will integrate with it once and stop thinking about it.
