Axiom Command Deck

Competencies

weights sum to 1.00

Name	ID	Weight	Definition
Financial Systems Design	financial_systems_design	0.30	Design and implement bulletproof payment state machines where every state is recoverable and every transition is idempotent, ensuring ledger consistency and money-movement correctness across millions of daily transactions.
Distributed Systems Mastery	distributed_systems_mastery	0.25	Apply deep knowledge of consensus, ordering guarantees, retry semantics, and idempotency patterns to prevent data loss and corruption in payment processing pipelines; understand failure modes in Kafka-based architectures.
Postgres for Transactional Workloads	postgres_transactional_scale	0.25	Design normalized schemas and query patterns that maintain ACID guarantees under high-throughput payment processing; optimize for both consistency and performance in financial ledger systems.
Operational Ownership & Incident Excellence	operational_ownership	0.20	Own services end-to-end from design through on-call support; conduct root-cause postmortems that identify systemic fixes and prevent recurrence of payment infrastructure failures.

Scoring Weights

Adjust how much each competency contributes to the final score. Changes apply to all future evaluations for this job spec.

financial_systems_design

30%0.30

Scoring guideline

distributed_systems_mastery

25%0.25

Scoring guideline

postgres_transactional_scale

25%0.25

Scoring guideline

operational_ownership

20%0.20

Scoring guideline

Total weight: 1.00 ✓ balanced

Interview questions

AI-generated from the JD · auto-published · edit anytime

Question count3 currently · candidate sees this many

Title

Difficulty

Time budget (min)

Prompt

You're building a payment processing service that receives webhook retries from upstream payment providers. Each webhook may arrive multiple times with the same idempotency_key, and you must guarantee that a payment is recorded exactly once in your ledger, even under concurrent retries.

Design and implement a function that:
1. Accepts a payment event (user_id, amount, currency, idempotency_key, timestamp)
2. Returns the transaction_id if successfully recorded, or the existing transaction_id if this idempotency_key was already processed
3. Raises PaymentError if the same idempotency_key arrives with different amounts (fraud signal)
4. Must be safe against concurrent calls with identical idempotency_keys

Assume you have access to a simple in-memory idempotency store (dict) for this problem. In production this would be Postgres with a unique constraint on idempotency_key.

Example:
process_payment('user123', 50.00, 'USD', 'idem-abc', 1000) → 'txn_001'
process_payment('user123', 50.00, 'USD', 'idem-abc', 1001) → 'txn_001' (idempotent repeat)
process_payment('user123', 60.00, 'USD', 'idem-abc', 1002) → PaymentError (amount mismatch)

Starter code

Hidden tests

Hints (one per line)

Behavioral round (Round 02)

Voice Q&A · pre-generated from the JD · edit anytime

4 prompts · Cal walks through each in order during Round 02

Prompt

Target competency

Time (min)

Follow-up (optional)

Live performance

Aggregated from candidates who took this job spec.

Interviews

1

0 completed

Avg score

—

out of 100

Completion

0%

0 of 1

Avg score per competency

Financial Systems Designweight 0.30—n=0

Distributed Systems Masteryweight 0.25—n=0

Must-haves

required5+ years building backend systems in production with demonstrated Python expertise
requiredStrong SQL skills with experience designing schemas for high-throughput transactional workloads on Postgres
requiredDeep understanding of distributed systems concepts (consensus, ordering, retries, idempotency) and their application to payment processing
requiredTrack record of owning incidents, writing comprehensive postmortems, and implementing preventative improvements

Senior Backend Engineer — Payments Platform

Competencies

Scoring Weights

Interview questions

Behavioral round (Round 02)

Live performance

Must-haves