Backend Engineer — API Platform

About the role

Verizol sells corporate intelligence and verification as APIs — company search, daily incorporation alerts, registry watchlists, KYB verification, and a growing catalogue of identity and business-verification endpoints.

You build the platform those APIs run on. Not one endpoint — the layer that makes every endpoint consistent: authentication, keys, rate limiting, usage metering, billing, webhooks, and a vendor-abstraction layer that lets us swap an upstream provider without a single customer noticing.

Our customers are engineers integrating us into onboarding and risk flows. That sets the bar: our docs, error semantics, and uptime are the product.

What you'll own

API platform core

• API key issuance, scoping, and rotation; environment separation (sandbox vs production).
• Rate limiting and quota enforcement per key, per plan, per endpoint.
• Usage metering that is accurate enough to bill from — every call counted once, reconcilable, auditable.
• Consistent request/response envelopes and error taxonomy across the entire catalogue, so endpoint #200 behaves exactly like endpoint #1.

Vendor abstraction layer

• Many endpoints are fulfilled by upstream aggregators. Build the adapter pattern that normalises their wildly inconsistent responses into our schema.
• Failover and routing: if a primary vendor is down or degraded, route to secondary without customer-visible failure.
• Per-vendor cost tracking, latency monitoring, and circuit breakers.

Product surfaces

• KYB verification endpoints — PAN match, charges, director status, filings, penalties.
• Alerts and watchlists: subscription management, filter evaluation, delivery via email, webhook, and Sheets.
• Webhook infrastructure — signed payloads, retries with backoff, dead-letter handling, replay.

Reliability and observability

• Structured logging, request tracing, per-endpoint latency and error dashboards.
• Async job processing for anything slow (document pulls, bulk lookups, report generation).
• Caching strategy that respects data freshness requirements — registry data ages differently by field.

Developer experience

• Maintain OpenAPI specs as the source of truth; keep public docs accurate as the catalogue grows.
• Sandbox with realistic mock responses so customers can integrate before they pay.

Requirements

Must have

• 2+ years building and operating production REST APIs.
• Strong in one of Python (FastAPI/Django) or Node.js (NestJS/Express). We'll weight depth over which one.
• Solid PostgreSQL — schema design, transactions, indexing, and knowing when the query plan is lying to you.
• Redis, caching patterns, and background job processing (Celery, BullMQ, or equivalent).
• Authentication and authorisation done properly — API keys, JWT, HMAC request signing.
• Docker, Linux, Git, AWS.
• You write tests for things that touch money or customer data, without being asked.

Good to have

• Experience in fintech, KYC/KYB, or verification infrastructure — Surepass, Karza, Perfios, Signzy, Cashfree, or similar as either builder or integrator.
• Metering and usage-based billing implementation.
• Payment gateway integration (Razorpay, Stripe).
• Multi-tenant SaaS patterns, RBAC, audit logging.
• Awareness of DPDP Act consent and data-retention requirements as they apply to verification APIs.

Typical stack

FastAPI or NestJS · PostgreSQL · Redis · Celery / BullMQ · Docker · AWS (EC2, RDS, S3, SQS) · OpenAPI · Grafana / Sentry

What success looks like

TimeframeOutcome30 daysShipped your first customer-facing endpoints. You understand the vendor adapter layer and have found at least one inconsistency in our existing API surface worth fixing.60 daysMetering and rate limiting reliable enough to bill from. Webhook delivery hardened with retries and replay.90 daysNew endpoints ship in days, not weeks, because the platform pattern is solid — you've made the catalogue expansion a filling-in exercise rather than a rebuild.

Why this role is interesting

• We're building toward a several-hundred-endpoint catalogue. That only works if the platform layer is genuinely good — otherwise the 50th integration takes as long as the 5th and the roadmap dies. You're solving the leverage problem, not grinding through CRUD.