Agustin JacobSenior backend engineer 0 of 8 places Read my CV
UnexploredLevel 5: your team? Here be monsters: production

GET /AGUSTIN

Pick a place. Each is something I build, with a 20-second game.

Teams say quality matters, then live with flaky tests, slow pipelines and manual checks before every release. I want the people who write the code to own its tests and its pipeline.

Where I did itCut CI validation time by 40% with parallel execution, and built validation tooling adopted by 5 teams and used by 70+ engineers.

I've cut CI validation time by 40%, and built validation tooling used by 70+ engineers.

More details

Most confidence should come from integration tests that run real code paths against a real database: the testing trophy. A thin layer of end-to-end browser tests covers the critical flows. End-to-end suites are slow and fragile, so they should be the exception.

Speed comes from splitting suites into parallel shards using timing data, caching dependencies and Docker layers, and keeping slow checks off the critical path.

A flaky test gets quarantined as soon as it's detected, then fixed or deleted. A suite people rerun until it goes green teaches everyone to ignore red.

I've built Jenkins, Azure DevOps and CircleCI pipelines, cut CI validation time by 40% through parallel execution, and built automated validation adopted by 5 teams and used by 70+ engineers.

Try itYou are a pull request. Press Play, then tap or press space to jump the flaky-test imps on your way to production.

You are a pull request

Run through CI to production. Jump the flaky tests, the imps: every hit is a rerun. Coins are cache hits that save time, and squires run your tests in parallel.

Tap or space to jump. Your best time is kept in this browser.

Build for the business you have today and keep the next change cheap. When reads outgrow one database, add read replicas and route traffic with care.

Where I did itDefined API contracts, service boundaries and data models across wallet, order and payment services.

More details

A village: one Django app and one Postgres database. A well-structured monolith, with clear modules and a service layer between views and models, is the fastest way to learn what the business needs, and it splits cleanly later.

A town: when reads get hot, put a Redis cache in front of the expensive queries, with short TTLs or explicit invalidation. When requests wait on slow work like emails, payments or reports, move it to Celery workers and return early.

A city: queues between components so a slow consumer never blocks a producer, read replicas for read-heavy endpoints, autoscaling workers, and metrics, traces and error tracking to show which part is the real bottleneck.

A kingdom: split into services when separate teams need to deploy on their own schedule. Every split buys you network failures, versioned contracts and distributed debugging, so it should pay for itself.

Read replicas: copies of the primary that serve reads. They trail a little behind, so a user who has just written should read from the primary until replication catches up. That rule is read-your-writes. Writes always go to the primary.

AI made internal tools like admin panels, dashboards and security scanners cheap to build. Before building one instead of buying it, I still ask who will maintain it, patch it and get paged for it.

Try itYou are the load balancer. Press Play, then send each request to the primary or one of the replicas.

you: the load balancer Primary reads and writes Replica A reads only · 1.6 s behind Replica B reads only · 1.6 s behind

You are the load balancer

Requests arrive on the left: R is a read, W is a write. A gold ring means the reader just wrote something and wants to see it. Send each one to a database before the queue backs up.

Keys 1, 2 and 3 work too. 30 seconds, 3 lives.

I built the wallet for a services marketplace: balances, top-ups, payments and refunds. Money bugs hide in the milliseconds, and retries are where they breed.

Where I did itBuilt a marketplace wallet: transactional balance updates, Stripe payments and refunds through its API and webhooks, Celery workers on Redis.

More details

The race in the toy is a lost update. Both requests read the balance, both decide there is enough, both write. The fix is to make the check and the write a single atomic step, either with a row lock:

with transaction.atomic():
    wallet = Wallet.objects.select_for_update().get(pk=wallet_id)
    if wallet.balance < amount:
        raise InsufficientFunds
    wallet.balance -= amount
    wallet.save(update_fields=["balance"])

or with a conditional update that holds no lock across Python code:

updated = Wallet.objects.filter(
    pk=wallet_id, balance__gte=amount,
).update(balance=F("balance") - amount)
if not updated:
    raise InsufficientFunds

Retries are the second trap. A client times out, retries, and pays twice. Every endpoint that moves money should accept an idempotency key, store it with the result in the same transaction, and return the stored result when the same key comes back. Stripe's API works this way.

Recording every movement as an immutable ledger entry, and deriving the balance from it, means you can always explain where each coin went.

The wallet I built exposed APIs for balances, top-ups, payments and refunds with Django REST Framework and PostgreSQL, used Stripe's API and webhooks for payments and refunds, and ran Celery workers on Redis for asynchronous payment processing and notifications.

Try itYou are the payments API. Charge new requests. If you've already been paid for that key, replay the receipt instead.

This is Production. She hates paying twice.

Pay 30 gold

Idempotency store: keys already paid

    You are the payments API

    Every payment carries an idempotency key, the sigil. Clients retry when the network fails, so some keys come back. New key: charge it. Key you've already been paid for: replay the receipt.

    Keys C and R work too. 25 seconds, 3 lives.

    Every product depends on services it doesn't control, like a payment provider. When one goes down, a good system stops waiting on it, answers fast, and checks back later.

    Where I did itLed production debugging and root-cause analysis with Datadog, Sentry and Mixpanel.

    More details

    A circuit breaker wraps every call to a dependency and counts failures:

    closed  --3 failures-->  open  --cooldown-->  half-open
       ^                                          |
       +--------------- trial call succeeds -------+
                        trial call fails  --> open

    While it's closed, calls go through. Once it's open, calls fail immediately without touching the dependency. After a cooldown it lets one trial call through, and closes again only if that call succeeds.

    Without one, every request waits out the full timeout. Threads, connections and worker slots fill up with calls that are just waiting, and an outage at a payment provider becomes an outage in your own API. Failing fast keeps the rest of the product working and gives the dependency room to recover.

    It works best alongside timeouts on every outbound call, retries with exponential backoff and jitter for transient errors, and a fallback for the user, like queueing the payment or showing “try again later”.

    In the game, the bridge is the breaker, the payment kingdom is the dependency, and you are the failure counter.

    Try itYou are the circuit breaker. Press Play, then hold to open it (the bridge rises) while the payment provider burns. Let go to close it.

    Our API Payment provider

    You are the circuit breaker

    Knights are requests to a payment provider. When it catches fire, hold to open the breaker so requests fail fast instead of burning. Let go to close it once the fire is out.

    Hold the scene or the space bar. 20 seconds, 3 lives.

    I designed and ran an AI search that finds the right candidates for a job in a large candidate database.

    Where I did itDesigned and ran a RAG service that matches candidates to job roles, on AWS SageMaker with LLM inference on Groq.

    More details

    Retrieval-augmented generation (RAG) finds the most relevant records first and only then asks a language model to reason over them, so answers are grounded in your own data instead of the model's memory.

    The one I designed and ran finds candidates for a specific job role in a company's candidate database, integrating AWS SageMaker with LLM inference on Groq.

    Most of the quality comes from the parts around the model. Chunking decides what a match even means: too big and every profile looks the same. Metadata filters for seniority, location and role stop a junior frontend profile from ranking for a staff backend job. A fixed evaluation set of queries with known good answers, run on every change, tells you whether a tweak helped.

    The oracle here is a tiny version. It scores eight short profiles with TF-IDF and cosine similarity instead of embeddings, entirely in your browser, and caches each answer under the normalised question:

    score(q, d) = (q · d) / (|q| × |d|)
    weight(term) = (1 + log tf) × (log((N + 1) / (df + 1)) + 1)

    If the pool is a few hundred people your recruiters already know, a SQL filter and a good search box beat a RAG pipeline.

    Try itYou are the retriever. For each job, pick the three scrolls you'd hand the oracle, then see how the real ranking compares.

    “Senior Python backend engineer with payments experience”

    Pick the 3 scrolls you'd hand the oracle.

      You are the retriever

      RAG works in two steps: retrieve the few documents worth reading, then let the model answer from them. You do step one. Three jobs, three picks each.

      Scoring is real TF-IDF with cosine similarity, in your browser.

      A cache keeps what people ask for most close at hand, so the slow trip to the database happens less often.

      More details

      A cache trades memory for speed. A hit is answered from fast storage in about a millisecond; a miss pays the full trip to the database and usually fills the cache on the way back.

      The hard parts are deciding what to keep (eviction policies like least recently used or least frequently used), how long to trust it (TTLs, and explicit invalidation when the data changes), and protecting the database when a popular key expires and everyone misses at once. That last one is a cache stampede, and request coalescing or early refresh prevents it.

      In Django that usually means Redis behind the cache framework, with versioned keys so a deploy can invalidate them safely.

      The books readers ask for in the game are my reading list. Draft shelf

      • Designing Data-Intensive Applications, Martin Kleppmann. The map of the whole realm: storage, replication, streams, and what actually happens when two writes race.
      • Release It!, Michael T. Nygard. Where the circuit breaker got its name.
      • Accelerate, Nicole Forsgren, Jez Humble, Gene Kim. The research behind fast pipelines and small batches.
      • A Philosophy of Software Design, John Ousterhout. Deep modules with small interfaces.
      • Team Topologies, Matthew Skelton, Manuel Pais. How team shapes decide system shapes.
      • Site Reliability Engineering, Betsy Beyer, Chris Jones, Jennifer Petoff, Niall Richard Murphy. Error budgets, toil, and on-call that doesn't burn people out.
      • Write tests. Not too many. Mostly integration., Kent C. Dodds. The testing trophy behind the Gauntlet.
      • Designing robust and predictable APIs with idempotency, Brandur Leach, Stripe. Idempotency keys, from people who move money for a living.
      • Circuit Breaker, Martin Fowler. The short version of the Drawbridge.

      Try itYou are the cache. Keep the books readers ask for on your desk. Every miss is a slow trip to the stacks.

      A reader asks for

      Readers will ask for these books. Popular ones come back often.

      Your desk, the cache: 3 slots

      The stacks, the database: slow

      You are the cache

      Twenty readers ask for books. A book on your desk is a hit, served in a millisecond. Anything else is a miss and a slow walk to the stacks. When the desk is full, you choose what to put back.

      Your score is the hit ratio. Your best is kept in this browser.

      I like teams where developers own the whole job, from deciding what to build to supporting it in production.

      Where I did itOwned backend and AI features from requirements and system design to AWS deployment and production support.

      More details

      In practice a team owns a feature end to end. It shapes the ticket with product, designs the data model, ships behind a feature flag, watches the dashboard after release and answers the alerts. Nothing gets handed over a wall to a separate QA or DevOps team.

      Control comes from automation instead of approval chains. Linting, formatting, type checks and tests run on every pull request, so reviews can be about design instead of style. Shared conventions for project layout, naming, migrations and logging mean any engineer can open any service and find their way around.

      Documentation is shared across teams. Decisions, runbooks and architecture notes live next to the code, and whoever makes a change updates them.

      The cost is trust and onboarding. This works when people can see the impact of what they ship and have the context to make good calls on their own.

      Try itSpin the table, or flick it, and see where the lance lands. Each seat is something developers should own. Mine is the one with the mate.

      { } Someone left a mate at the Code seat.

      AI is the most powerful tool we've had since the internet. It also means more code to maintain and more security holes to catch.

      I use it every day, and I review what it writes like a pull request from a fast colleague who has never seen production.

      What AI got wrong building this site
      • RejectedIt described me as ten years in QA. I've been a developer since 2018.
      • RejectedIt picked the fonts half the AI-built web uses. I made it check.
      • RejectedIt designed a complete first version of this site. I called it slop and threw it away.
      • RejectedIt wrote a slogan headline and a “When I'd be wrong” note for every room. Both read as AI.
      • RejectedIt gave every card a hard offset shadow, like half the apps AI builds.
      • RejectedIt wrote too much, and too technically for the people who read portfolios. Most of it now lives behind “More details”.
      • RejectedIt put company names all over the rooms. They live in the CV now.
      • RejectedIt made everything move on its own. Now nothing moves until you scroll or click.
      • RejectedIt put a pull-the-pin puzzle on the front page. It's gone.
      • RejectedIt credited its own fonts in the footer.
      • BugFor two versions the drawbridge never rose. The room and the bridge shared an id.
      • BugThe flaky-test imp was invisible. Its id clashed with its own drawing.
      • BugThe first bridge game was unwinnable. Knights already on the road when the smoke appeared could not be saved.
      • BugMy knight walked into the wall above the gate instead of through it.
      • BugEvery toggle shield rendered as a solid black blob.

      Try itYou are the code reviewer. The familiar is writing a pull request. Reject the lines that would hurt production before they merge.

      Hello! I wrote the rest of the page while you were reading. All tests pass.

      Pull request #42 · by the familiarmerges into main ↑

      You are the code reviewer

      The familiar writes code fast and with total confidence. Lines scroll up toward main. Click the ones that must not merge. Leave the good ones alone.

      Click a line to reject it. Blocking a good line costs a life too.

      Level 5 is your team. Here's everything, on one page.

      200 OK

      Your request made it back in a moment. You spent a while in the castle. Here's what I brought back.

      Agustin Nicolas Jacob

      Senior Backend Engineer · Python, Django, Angular, AWS, LLM/RAG

      Buenos Aires, ArgentinaLinkedInGitHub

      Summary

      Backend engineer with 10+ years in software engineering, the last 7+ building production Python/Django services. At TestGorilla, owned backend and AI features from system design to AWS deployment: Django REST Framework APIs, Celery workflows, Angular front ends, and a production RAG service that matches candidates to job roles. At DataArt, built a wallet service with PostgreSQL and Stripe for a services marketplace. Background in testing, CI/CD, and observability.

      Experience

      TestGorilla · AI-powered talent platformAugust 2022 – October 2026

      Senior Software Engineer, Backend & Product

      • Owned delivery of backend and AI features, from requirements and system design through deployment and production support.
      • Designed and operated a production RAG service that finds candidates for a specific job role in the company's candidate database, integrating AWS SageMaker with LLM inference on Groq.
      • Built Django REST Framework APIs, MySQL data models, custom integrations, and asynchronous Celery workflows.
      • Delivered full-stack workflows using Angular, TypeScript, and Jest.
      • Deployed Dockerized services to AWS ECS, backed by RDS (MySQL) and S3, and owned the CircleCI pipelines and production releases.
      • Led production debugging and root-cause analysis with Datadog, Sentry, and Mixpanel.
      • Built reusable engineering tooling and automated validation adopted by 5 teams and used by 70+ engineers.
      • Built AI-powered n8n workflows for non-technical departments.
      DataArt · Software & Technology Consulting (Remote)May 2019 – August 2022

      Senior Software Engineer

      • Built Python/Django backend services for a client's e-commerce marketplace where customers hire and pay service providers, covering service listings, orders, and payments.
      • Developed the platform's wallet service with Django REST Framework and PostgreSQL, exposing APIs for balances, top-ups, payments, and refunds, with transactional updates to keep balances consistent.
      • Integrated Stripe for payments and refunds through its API and webhooks, and built Celery workers backed by Redis for asynchronous payment processing and notifications.
      • Contributed to system design and architecture decisions, defining API contracts, service boundaries, and data models across the wallet, order, and payment services.
      • Also built Java/Spring backend services and REST APIs.
      • Built internal backend tooling for environment setup, test data, and diagnostics.
      • Built Jenkins and Azure DevOps pipelines for build, validation, and deployment, and reduced CI validation time by 40% through parallel execution.
      SecureAuth Corporation · Identity & Access Management (Remote)September 2018 – May 2019

      Software Engineer

      • Built Django-based internal services and Python backend tooling for REST and SCIM API integrations.
      • Implemented SCIM provisioning and REST integration endpoints to sync users and groups between the platform and third-party identity systems.
      • Analyzed API design, scalability, and performance trade-offs in authentication and provisioning flows, building load-testing tooling with pytest and JMeter.
      • Wrote unit and integration tests with pytest, took part in code reviews, and debugged integration issues across services.
      • Maintained Dockerized Jenkins environments and CI workflows; presented technical risks and trade-offs to executive stakeholders.
      Globant · Technology Consulting (Buenos Aires)April 2016 – September 2018

      Software Development Engineer in Test

      • Built reusable Python tooling for REST and SOAP service validation and test data, supporting 3,000+ automated scenarios across distributed, service-oriented systems.
      • Worked with developers to reproduce, debug, and document defects in REST and SOAP services, using logs and API traces to narrow down root causes.
      • Managed Azure DevOps pipelines, agents, artifacts, and deployments for continuous delivery.
      • Partnered with client architects on service integration and system design reviews for US and Fortune 500 clients.

      Technical skills

      Languages
      Python, TypeScript, Java, SQL
      Backend & integrations
      Django, Django REST Framework, Celery, PostgreSQL, MySQL, Redis, REST APIs, API Design, Stripe, Spring, SCIM, SOAP
      Frontend
      Angular, Jest
      Cloud & delivery
      AWS (ECS, RDS, S3), Docker, CI/CD, CircleCI, Jenkins, Azure DevOps, Linux
      AI, automation & data
      LLM Applications, Retrieval-Augmented Generation (RAG), Groq, AWS SageMaker, AI-Assisted Engineering (Claude), n8n, Snowflake, Mixpanel
      Observability & reliability
      Datadog, Sentry, pytest, Playwright

      Languages

      English: C2 · Spanish: Native

      Education

      • Bachelor's Degree in Political Science, Universidad de Buenos Aires
      • Studies toward a degree in Information Systems Engineering, Universidad Tecnológica Nacional, 2019

      Built by Agustin Jacob with an AI familiar, arguing the whole way. No cookies, no trackers.