Developer Analyst
A developer analyst reads code, writes SQL, and debugs production instead of waiting on someone who can. This pillar covers that craft in practice: querying the database to find the truth, reading an API contract without a developer, tracing one transaction through production logs, and using Git, Python, and regex to automate the work you repeat. Written for analysts who want to contribute well beyond requirements, with skills you can apply on your next ticket.
The parts for a developer analyst joining a new team: AI on the repository you did not write, and the role guide that starts with an FF01 rejection ticket and ends with a root cause note.
The engineering half of requirements work: YAML with a schema validator, MCP and scoped API tokens for Jira, Confluence, Xray, and Datadog, and coverage gates in CI.
The parts that put a model against real systems: reading a repository you did not write, and writing SQL you can actually defend.
Use agentic coding tools as an analyst who codes: plan mode, permission modes, AGENTS.md and CLAUDE.md, hooks, worktrees, and four jobs with the guardrails.
The observability requirements an analyst writes for a payment API: golden signals, SLOs and error budgets, log fields, metrics, alerts, and Gherkin checks.
The Arazzo Specification for analysts: sourceDescriptions, steps, successCriteria, and runtime expressions, with a Stripe payment-to-refund workflow to run.
How analysts write LLM evals: a golden set from acceptance criteria, code graders vs LLM-as-judge, pass thresholds as release criteria, and regression in CI.
What changed from OpenAPI 3.0 to 3.1 and 3.2, from nullable to type arrays, webhooks, QUERY and streaming, and what to check when a provider upgrades.
Read OpenTelemetry traces like an analyst: spans, attributes, the traceparent header, trace_id vs UETR, and finding the slow span in Jaeger, Tempo, or Datadog.
Postman CLI vs Newman in CI: install and run commands, JUnit reports, spec linting, where results go, GitHub Actions YAML, and the git-native Bruno CLI.
Fuzz an API from its OpenAPI contract with Schemathesis 4: run command, checks, negative and stateful tests, JUnit in CI, and triaging findings into defects.
How to specify an MCP server for your own API: which operations become tools, schemas, OAuth scopes, approval for writes, audit, injection risk, and tests.
How analysts use AI to onboard faster: check the approved tool first, then build a glossary, grounded message explainers, session notes, and a questions list.
A 90 day onboarding plan for technical analysts in four phases: orient, map, contribute, own. What to produce each week, with a banking ISO 20022 example.
Developer analyst onboarding: week one access, reading the repo with AI, tracing a pain.001 by its identifiers through logs and SQL, and a root cause note.
Every analyst career move on one map: switching in, going more or less technical, moving up, and earning more, with timelines, pay deltas, and real cases.
Analyst contract rates in 2026 for the US, Canada, UK, and eurozone, the structures (1099, CCPC, IR35, portage), and the floor-rate math behind real take-home.
Rewrite your CV for an analyst role change: bullets as artifact plus outcome plus number, before and after pairs, ATS rules, and CV norms in four markets.
Realistic 2026 analyst pay by role and level in the US, Canada, UK, and Eurozone: BA, technical BA, QA, SDET, data, architecture, product, and contract rates.
How analysts negotiate an offer or a raise: word-for-word scripts, an evidence file with numbers, timing, non-salary items, and US, Canada, UK, and EU norms.
How analysts become analytics engineers: dbt, SQL, Git, tests, and modelling in 6 to 12 months, realistic 2026 pay in four markets, and a portfolio spec.
Technical analyst to forward deployed engineer, solutions engineer, or implementation consultant: what each does, 2026 pay, skills that transfer, and the gap.
Technical analyst to software developer in 2026: junior hiring is tight and AI compresses junior coding, so go internal and use your domain. Pay, plan, cases.
Is business analysis safe from AI? Which BA tasks AI already does, which it cannot, the roles most exposed, and the five career moves that hedge, with 2026 pay.
Data analyst to business analyst: what transfers, what you must learn, realistic 2026 pay in four markets, three composite cases, and a six month plan.
Moving from software developer to business analyst: the real pay cut, why technical BA or systems analyst is the better target, what transfers, and a plan.
How to become a technical business analyst: SQL, APIs, logs, and scripting in six months on your project, one artifact a month, and a 10 to 20 percent pay jump.
Manual QA to SDET pays 25 to 40 percent more at the same level. The stack to learn, a 6 to 12 month plan with artifacts, the AI angle, and three real moves.
Proactive developers find the problem before the ticket and coach juniors who generate more than they can judge. The habits, templates, and formats that work.
When AI generates code in seconds, a developer's value moves to proving it works: testing, review, quality, release notes, demos, proactivity, and coaching.
AI writes tests that mirror the code, bugs included. Derive tests from the requirement, add property and contract tests, prove the suite with mutation testing.
How developers write release notes per audience and run demos that end in a decision, with templates, a worked payments example, and where AI drafting helps.
Reviewing AI-generated code: the failure modes to hunt for, the review order that finds them, what CI should automate, and a PR template that makes it fast.
Generate a Mermaid sequence diagram from a Bruno or Postman collection run: the trace script, the Postman CLI or newman JSON export, the prompt, and CI wiring.
Turn manual Kafka checks into an automated Postman collection: produce and consume over REST Proxy, poll with backoff, assert schema and ordering, run in CI.
Wire an assistant to Jira, Confluence, Xray, and Datadog with scoped tokens and MCP: read safely, publish idempotently, keep every write reviewable in git.
Write business and functional requirements as YAML with stable ids, validate them with a schema, and render the BRD and FRD humans read from the same source.
Turn correlated Splunk or Datadog logs into an accurate Mermaid sequence diagram with AI. The queries, the export shape, the prompt, and the verification step.
Write a test strategy that makes decisions, turn conditions into an executable suite, run it in CI with Xray and Datadog, and generate coverage proof.
How the whole AI analyst stack fits into a real week, the 90-day build order, what to measure, how to lead adoption on your team, and what to put on your CV.
Turn an OpenAPI contract into a Bruno or Postman collection with real assertions, generate the chaining scripts, and put the whole suite behind a CI gate.
Point AI at the repo and answer what no document can: where a rule really lives, what a status actually means, what a pull request changes for the business.
Use AI to write the SQL you can verify, define metrics that survive scrutiny, build the dashboard nobody had time for, and automate the weekly delivery pack.
Point an AI assistant at your Obsidian vault so fourteen months of notes answer questions directly, and structure the vault so answers stay traceable.
The write side of an AI connection: what to automate, what never to, the approval pattern, the dedicated account, and keeping generated tickets human owned.
How a camt.053 is structured: balance types, entries, entry details, bank transaction codes, and the references that match a statement line to a payment.
What the Model Context Protocol is, how to connect an assistant to Jira and Confluence safely, and the six read-only questions that pay for the setup in a week.
Why analysts who send, chain, and script API requests move faster: verified requirements, reproducible defects, faster triage, credible POCs, and a 30-day plan.
How an analyst builds an API proof of concept: the decision it must settle, a two-day spike, mocks from OpenAPI, webhook proof, a scripted demo, and evidence.
Chain API requests in Bruno and Postman: capture values, pre-request and post-response scripts, token refresh, polling, branching, and a Stripe sandbox flow.
The OWASP API Security Top 10 (2023) as test cases analysts can run in Bruno or Postman: object and field authorization, auth, limits, business flows, and more.
How to write API test cases from the contract: a six-source derivation method, 40 worked cases for one payment endpoint, and data-driven automation in Bruno.
Run API test collections in CI with Bruno CLI, Postman CLI, or Newman in GitHub Actions: secrets, tags, JUnit and HTML reports, private networks, flaky tests.
Build a first API collection in Bruno and Postman: environments, variable precedence, inherited auth, secrets in .env or a vault, and cURL imports.
GraphQL for analysts: queries, variables, mutations, errors returned with HTTP 200, cursor pagination, and hands-on testing of the GitHub GraphQL API in Bruno.
How webhooks work and what analysts must specify: events, signatures, retries, duplicates, and ordering, plus testing with webhook.site and the Stripe CLI.
What an API is and how one works, for analysts: request and response, methods, headers, auth, status codes, and a real GitHub API call you can send today.
Troubleshoot failed API requests by symptom: connection and SSL errors, 401 vs 403, wrong-URL 404s, 415 and 422, 429, 5xx, CORS, and unresolved variables.
Small businesses now need SEO and GEO: ranking in Google and being quotable by AI answer engines. The shared technical base, what GEO adds, and how to measure.
When an AI agent beats a single prompt for analyst work, what tools it needs, where the guardrails go, and the three agent flows worth building first.
The five AI flows that measurably speed up analyst delivery: transcript to draft spec, negative test matrix, test data, log triage, and contract diffs.
Which analyst tasks to automate first, ranked by payback: environment checks, test data setup, reconciliation, contract validation, ticket evidence.
How to build a second brain as a technical analyst: a plain-Markdown knowledge base, organized by system and decision, that answers questions months later.
Developers do not need you to read code. They need decisions, edge cases answered before they hit them, and the why behind the what. The questions that work.
The difference between an API key, a personal access token, and an OAuth token, how to scope and rotate them, and where they belong across an analyst toolchain.
Use a personal access token and the Jira and Confluence REST APIs to generate traceability matrices and publish specs, with working Python scripts.
Bruno keeps API collections as files in your repo with no account; Postman wraps them in a cloud platform, now with Native Git. Trade-offs for pacs.008 tests.
A Claude Skill packages your method, references, and scripts into a folder the model loads on demand. Build one that writes pacs.008 test cases.
Migration programmes scope the payment rail and forget everything reading it: screening, monitoring, the warehouse, reports. The downstream impact register.
Namespaces, element order, the business header, empty vs absent, amount precision, and code choices. The XML layer that fails messages your test tool accepts.
How to build an Obsidian vault for analyst work: folder structure, atomic notes per ISO 20022 message and reason code, daily investigation logs, and Jira sync.
What slowly changing dimensions are, how SCD Type 1 and Type 2 differ, how a Type 2 table works with valid_from and valid_to, and how to query it correctly.
Smoke testing proves the build is testable, sanity testing proves a fix landed, regression testing proves nothing else broke. How they differ, when each runs.
SQL window functions and the three patterns analysts use daily: ROW_NUMBER for latest record per group, LAG for event timing, SUM OVER for running totals.
Airflow schedules tasks; Dagster declares the data assets those tasks produce. What the task vs asset split means for lineage, testing, and debugging pipelines.
A business analyst describes intended behavior; a technical BA verifies it against the running system. What separates the roles and how to cross the gap.
Data engineers build the pipelines and platforms that move data; analytics engineers model it in the warehouse so it means something. The split, explained.
A data mesh decentralizes data: domains own and publish their data as products, on a self-serve platform, under federated governance. Explained with a diagram.
A dbt DAG is the dependency graph of transformations, built from ref() calls. How to read one, the staging to marts convention, and why tests sit on nodes.
dbt and SQLMesh both turn SQL into tested, versioned transformation pipelines. Where they differ: SQL parsing, environments, incremental state, and lineage.
Both write code against the same systems. The backend developer owns the production system; the developer analyst uses code to verify and automate analysis.
Fivetran and Airbyte both move source data into your warehouse. They differ on openness, hosting, pricing, and who fixes the connector when the API changes.
Kimball builds dimensional marts first and integrates through conformed dimensions; Inmon builds a normalized enterprise warehouse first. The debate, mapped.
A warehouse is a managed analytical database; a lakehouse adds warehouse guarantees to open files on object storage. The real differences, with a diagram.
Looker is a code-defined semantic layer that governs metrics; Tableau is the strongest visual exploration tool. What each optimizes for and when each fits.
The medallion architecture organizes a lakehouse into bronze (raw), silver (cleaned), and gold (business-ready) layers. What each layer owns, with a diagram.
Medallion and Data Vault answer different questions: medallion says how many quality layers, Data Vault says how to model history inside them. With diagrams.
A QA analyst derives what must be tested from requirements and risk; a test engineer builds the automation that runs it at scale. The split and the overlap.
Snowflake and BigQuery are both elastic cloud warehouses. They differ on compute models, pricing units, cloud lock-in, and the knobs your team must operate.
Star and snowflake schemas differ in one thing: whether dimensions are denormalized. What each looks like, when each fits, and how to read one. With diagrams.
A systems analyst maps how systems connect and behave; a solutions architect decides how they should, and answers for it. The line, the overlap, and the jump.
A self-assessment matrix of 25 skills across the five technical analyst hats, with three levels per skill and where to build each one. Original to this site.
Both are technical; the deliverables differ. A technical BA ships verified understanding and specs; an engineer ships production code. Which seat fits you.
A practitioner guide to API testing: status codes, response schemas, request chaining, authentication, error contracts, and checks that catch real defects.
What contract testing is, how it differs from integration testing, and how consumer-driven contracts catch breaking API and event changes before production.
What a data dictionary is, how to build one, and why one authoritative definition of every field prevents the ambiguity that breaks integrations and reports.
Field notes on going from intimidated to fluent with OpenAPI: what confused me, what clicked, and how reading the contract myself changed my analyst work.
The Git an analyst actually needs: clone, navigate, read a diff, browse history, and find when behavior changed. Read the codebase without breaking anything.
An analyst's guide to HTTP status codes: the 2xx, 4xx, and 5xx families, what each common code means, and why 202 Accepted vs 200 OK matters in payments.
How to test idempotency in APIs and event consumers: idempotency keys, duplicate requests, redelivered events, and race conditions behind double processing.
Integration patterns that wire systems: request-response, messaging, publish-subscribe, request-reply, batch file transfer, and webhooks. Payments examples.
How an analyst reads JSON: objects, arrays, nesting, and types. Understand API payloads, event messages, and config files without asking a developer.
A guide to testing Kafka: consuming events in a test, asserting schema and key, verifying ordering and duplicates, and checking consumer side effects.
Production support skills for technical analysts: triage, tracing transactions, reading logs, staying calm, and turning incidents into requirements.
How an analyst reads an API contract: endpoints, methods, request and response schemas, status codes, and OpenAPI structure, without asking a developer.
Field notes from a major payments incident: reading logs under pressure, what the trail revealed, and the observability lessons that became requirements.
How an analyst reads production logs to debug a system: correlation ids, log levels, searching by transaction, and following one request across services.
The regular expressions an analyst actually needs: matching patterns in logs, validating formats like IBAN and BIC, and searching data. Practical, not theory.
Regression testing in payment systems: what to retest, building a regression suite, risk-based selection, and automating checks that protect live behavior.
How an analyst uses Python to automate repetitive checks: calling APIs, comparing files, querying data, and chaining requests. Small scripts, large leverage.
The SQL a technical analyst actually needs: SELECT, WHERE, JOIN, GROUP BY, and reading state during analysis and testing. Not for reports: for finding truth.
Synchronous and asynchronous communication differ in whether the caller waits, and that choice shapes coupling, latency, resilience, and customer experience.
A developer analyst reads and writes enough code to verify, automate, and prototype without becoming a full-time engineer. What the role does in payments.
A QA analyst proves a system behaves correctly by testing it end to end, not by reading the spec. Here is what the role does in banking and payments.
A systems analyst maps how services, messages, and data flow across a system so the pieces work as a whole. Here is what the role does in banking and payments.
Why testing a payment flow end to end teaches you the system and the UX better than any diagram: microservices, Kafka, the database, logs, and pain.002.
Free account
A free account, no password: an email link signs you in. It saves your steps and self-assessments on the Labs, shows your missions on a dashboard, unlocks the solutions, and, if you tick the box, sends you new missions and articles when they ship.
Your email is used to sign you in. Nothing else, unless you ask. Privacy.