Product Operations Lead

The person who runs the engine room behind Saleshandy's product: keeping the vendors, costs, and margins healthy, making sure we're paid for everything customers use, and building the internal systems that hold it all together.

How to read this JD. This isn't a list of degrees or years of experience. It describes what this person actually needs to do in their first year, and how we'll know it's working. If you've done similar work before, you'll recognize yourself in it.

Why this role matters

Saleshandy is an end-to-end outreach platform. Our customers use it to find leads, reach out to them, and book meetings, and they pay us for the software through subscriptions and usage. That is how the business makes money.

Delivering that software runs on a lot of moving parts behind the scenes, and most of them cost us money every time they're used. To find a lead's email and phone number, we pay a chain of outside vendors for each lookup. To check an email is real, we pay verification vendors. To let customers send at scale, we set up email accounts on Microsoft, Google, and Azure. To power the AI features, we pay an AI vendor for the usage. These vendor costs are the engine room of the product, and they run thousands of times a minute.

The health of the business depends on two things staying in balance: every bit of usage a customer gets is properly accounted for and paid for, and every amount we spend with a vendor is actually needed and billed to us correctly. When either slips, we lose money quietly, and at our scale a small slip turns into a big number fast. Keeping that balance is what this role owns.

Here's what runs behind the product:

• Finding contact details (we call it "waterfall enrichment"). Our tool looks up a person's email and phone number by asking a chain of outside vendors one after another (Findymail, Prospeo, RocketReach, and more), then checks the emails are real through yet more vendors (BounceBan, ZeroBounce, UserBouncer, and more). Each of those vendor calls costs us money, but the customer pays one credit for the finished result, no matter how many calls it took us to get there. This happens thousands of times a minute.
• Email accounts. So customers can send at scale, we set up and provide Microsoft 365, Google Workspace, and Azure email accounts, sourced from those vendors.
• Email verification as a service. Customers pay us to check whether email addresses are real. Behind the scenes we use ZeroBounce, BounceBan, UserBouncer, and others, on prepaid credits.
• Buying data. We purchase contact data from large, top-tier data vendors and keep those relationships running.
• AI credits. Customers use AI inside our product to personalize their outreach at scale, and behind the scenes we pay an AI vendor for that usage.
• Subscriptions. Thousands of customers pay us on recurring plans across all of the above.

Right now, no single person owns this end to end. It's spread thinly across our product managers, and it needs more day-to-day attention than they can give it. We want one person to own it. Boiled down, it's three things, done relentlessly:

1. Get paid correctly for everything customers use. Not just that a customer is billed, but billed the right amount, for the right usage, on the right plan. The money leaks in the details: a unit that never gets counted, a plan priced wrong, or usage that quietly runs ahead of what we charge.
2. Don't overpay the vendors. No getting overcharged, and no paying for things customers have already stopped using.
3. Build the tools that watch all of this, so a problem shows up early on a dashboard instead of as a nasty surprise on an invoice.

Money is the core, but not the whole of it. The same person also makes sure we use the right vendors at the right quality so customers get the right result, and builds the internal systems that let our support, sales, and success teams serve customers properly. The rest of this document is the detail.

What this is like to work in

(So you can decide if it's a fit. The environment is part of the job.)

• Bootstrapped and profitable. We move fast and decide with data. What's respected here is results, not hours or titles.
• Real scale, real money. Thousands of lookups a minute, five to six main vendors, heavy AI usage, and a customer base in the thousands. A small leak of a few percent turns into a big number fast, which is exactly why this role exists.
• You build the function, you don't inherit it. This is our first dedicated hire for this work. There's no playbook waiting for you. You write it, own it, and hire into it as it grows.
• Close to engineering. Most fixes here are small internal tools. You'll decide what to build, work with engineers to build it, and own whether it actually worked.
• Close to the founders, flat structure. You'll work directly with the founders. High trust, high independence, and no ceiling set by your title. In-office, Ahmedabad, Monday to Friday.

What you'll accomplish

⭐ The core job

Own the operational backbone of everything that powers our product behind the scenes, end to end. Money sits at the core: you're the one person accountable for keeping the margins healthy, so you find where money leaks, seal it, and build the tools (and later the team) that keep it sealed. But the job is wider than money. It's also making sure we use the right vendor at the right quality so customers get the right result, and building the internal systems that let our support, sales, and success teams serve customers properly. Everything below is a piece of this.

1. Keep the margin math clean on every service

It's trickier than "what a vendor charges us versus what we charge the customer." A customer pays one flat credit for one finished result, say a verified email. But getting there can take several vendor calls behind the scenes (one enrichment vendor, then another, then a verifier), and we don't bill for each step. So the real cost of a result is the whole chain, not one call, and the margin is whatever is left of that credit after it. (Margin here is the money we keep before company-wide costs like building the product, marketing, and support.) If a result takes too many tries the margin shrinks, and can even go negative. At thousands of results a minute, small inefficiencies turn into real money.

Your job: for each service, know the true cost to produce one billed result (the whole chain, not a single call), know what we charge for it, and keep the gap healthy. Build the checks that prove customers are charged correctly, and that flag the moment the cost per result creeps up.

What good looks like: a live, trustworthy view of the true cost and the margin per result on each service, and no month where the behind-the-scenes cost of delivering results quietly climbs toward what we charge without you catching it and explaining why first.

2. Get the best result from the lookup chain for the least cost

Every contact lookup runs through several vendors in turn, thousands of times a minute, and each one charges us. Tune which vendor we ask first, in what order, and with what backups, so we get the best, correctly verified result at the lowest cost. That means using the right vendor for the right kind of request, dropping vendors who return junk or wrong data, catching runaway usage before it costs us, and never paying twice for a lookup that failed.

What good looks like: the cost to get one good, verified contact goes down over time while the quality holds or improves, you can explain which vendor to try first for which request and why, and any spike in spend gets flagged within minutes, not discovered on the invoice.

3. Stop the leaks in the email accounts we provide

For the Microsoft, Google, and Azure email accounts, three numbers should match but usually drift apart: what the vendor bills us, what we bill the customer, and what the customer actually pays. Your job is to close that gap. The classic leak: a customer cancels, but we keep paying the vendor for their email accounts, month after month, until someone notices. You make "someone notices" automatic.

What good looks like: we never pay a vendor for an account that isn't tied to a paying customer, access is switched off automatically when a customer leaves or stops paying, and the margin on these accounts holds instead of bleeding.

4. Keep thousands of subscriptions billing and collecting correctly

Look after (and where needed, help build) the internal systems that run the subscriptions, so revenue doesn't slip through the cracks: no usage that goes unbilled, no customer sitting on the wrong plan and paying too little, no failed payment that never gets chased, no renewal that quietly doesn't happen.

What good looks like: lost revenue is actually measured, not guessed, and shrinking; and the messy cases (failed payments, downgrades, mid-month changes) are handled by the system, not by hand every single time.

5. Own the vendor relationships and the negotiations

Be the point person for every outside vendor: contact data, verification, email infrastructure, and AI. Keep prepaid credit balances topped up so nothing stalls mid-run, check every invoice so overcharges never slip through, and negotiate better rates as our volume grows.

What good looks like: no overcharge gets past you, no vendor's credits run dry in the middle of an operation, and as we grow, what we pay per unit goes down, not up.

6. Build the internal systems that run all of this, and the tools the teams need

This is a builder role, not just a watcher one. Treat the internal tools as your own products: decide how they should work, spec them with engineering, and get them built. That covers three kinds of tools: the automatic checks and alerts that stop money leaking (usage checks, switch-off-on-cancellation, credit top-ups); the dashboards that put every important number in one place (margin per service, usage, credit balances, lost revenue, failed payments), so a problem shows up on a screen before it shows up on a bill; and the systems our support, sales, and success teams rely on to see a customer's usage, credits, and account clearly and fix things fast, so customers get serviced right.

What good looks like: the numbers live on dashboards you built and trust, the repeat firefights turn into systems that run themselves, and the customer-facing teams have what they need to serve customers well instead of chasing manual lookups.

7. Turn it into a real function, and later a team

Take this work off the product managers' plates, and turn a pile of scattered tasks into a clear, written, teachable function. As it grows, hire and lead a small team.

What good looks like: the PMs get their time back, there's a real function where there was none, and it keeps running even when you're not the one holding it all in your head.

How you'll know this role is right for you

We're not counting years, we're looking for proof. You'll do well here if you've actually done the things below. Be ready with real examples.

Must-haves (we won't compromise on these):

• You've owned a process from start to finish. You built it, ran it, and were on the hook for the result, ideally somewhere money or numbers were on the line.
• You're comfortable in the numbers. Costs, prices, margins, and spotting the one figure that's off inside a big pile of data.
• You can build with data. You've set up dashboards and reports from scratch and used them to catch problems early (Metabase, PostHog, SQL, or similar).
• You can turn a manual mess into a tool, with engineers. You've taken something done by hand and error-prone, decided how a tool should fix it, and driven the build, not just raised a ticket.

What makes a candidate stand out:

• You've actually negotiated with a vendor, on price or contract, not just fixed their errors.
• You've worked on billing, usage tracking, or subscription systems, and you know where money leaks in a pay-as-you-go business.
• You automate by instinct. When you see the same manual task twice, you reach to make it run itself.

Nice, but not the point:

Knowing sales tools, cold email, or email deliverability, being comfortable with usage-based billing, and being handy with tools like Metabase, PostHog, SQL, or light scripting all help, but they're a means to the work above, not the point.

Why Saleshandy

• Real ownership from day one, over work no one owns yet that ties directly to money the business keeps.
• Close to the founders, flat team. You'll have influence without waiting for a title, and your ceiling is what you can do, not what you're called.
• A sharp, fast team and founders who back this work because they can see it in the margins.
• Built in India, serving customers worldwide.

If you get a quiet kick out of finding the leak everyone else walked past, and sealing it for good, let's talk.