NIGHTLOOM DEVELOPMENT
01 / Portfolio9 projects · 8 with public code

Work you can open and read.

Client work stays private unless the client agrees to show it. Below are our own product and the builds we made in the open, held to the same standard. For each one: what it does, how it's built, how it was tested and where its limits are.

8projects with public code
4systems on n8n
1product in beta
5working days for the last client job

All cases

  1. Open-source build · n8n

    Greeter

    An AI receptionist for clinics that books only after the patient confirms.

    Load test: 100 dialogs · 0 lost
  2. Open-source build · n8n

    Stripe to Xero

    Paid Stripe invoices land in Xero exactly once, through repeats, rate limits and crashes.

    1,753 events · 0 duplicates
  3. Open-source build · n8n

    AI Content Factory

    One message in, a draft for every platform, approved by a person first.

    500 rows · 0 duplicates
  4. Open-source build · n8n

    Production n8n

    Self-hosted n8n that stays up through routine restarts.

    0 failed requests on routine restarts
  5. Client project

    sia.ie

    A summer camp site, reworked for Halloween in five working days.

    5 working days · live
  6. Own product · beta

    ISY

    Reviews how an AI agent did the work, right on the pull request.

    300+ tests · open CLI
  7. Open-source build · Rust

    CascadeRPC

    A Rust RPC gateway that spreads calls over providers by tier: 113k requests a second in a local benchmark.

    113k RPS · p99 5.74 ms
  8. Open-source build · Solana

    solar-relay

    When an RPC node fails mid-run, the pool trips its breaker and the calls keep landing.

    16 tests · 92% coverage
  9. Open-source build · AI

    AgentSafe

    An AI agent that can pay, but only within limits it cannot change.

    On-chain limits · 3‑min video
02 / n8n systems4 builds · 6 rules

Four systems on n8n, built the same way.

n8n work that has to stay correct under load: bookings, payments, publishing. We built these four in the open, and client work gets the same rules.

The path every event takes
  1. Receivethe webhook checks who sent it
  2. Storein Postgres, once, under the source's own id
  3. Processone item at a time, under a lease
  4. Reconcilea schedule finishes what was left undone

How we build on n8n

  1. 01

    Store before work

    The webhook checks who sent the event and stores it before any work starts. The work runs after, at the pace the other side allows.

    Greeter · Content Factory · Stripe to Xero

  2. 02

    Postgres keeps the truth

    n8n has no transactions across nodes, so every change is one call to an SQL function, which runs as one transaction. A crash between two nodes leaves nothing half written.

    Greeter · Content Factory

  3. 03

    Nothing twice

    Keys that come from the source system make every retry and every redelivered webhook a no-op.

    Greeter · Content Factory · Stripe to Xero

  4. 04

    Nothing left undone

    A scheduled pass finishes whatever a crash or a lost delivery left undone, and raises an alert when it cannot.

    Greeter · Content Factory · Stripe to Xero

  5. 05

    Queue mode where load needs it

    The editor, the webhooks and the workers run apart on a Redis queue, so a slow workflow never holds up a webhook.

    Greeter · Production n8n

  6. 06

    Workflows are code

    Workflow JSON lives in git, a linter checks every export, tests run against stubs of every external API, and failures alert in Telegram.

    Greeter · Content Factory

03 / Greetern8n-greeter

Open-source buildn8n · AI · Integrations

Greeter: An AI clinic receptionist that asks before it books

A front desk for dental clinics, built entirely on n8n. Patients write in Telegram, WhatsApp or the chat on the clinic's site, in English, Ukrainian or Russian. The assistant answers from the clinic's own data and books, moves and cancels visits. Status: open-source build, load-tested with a stub model; the end-to-end run on real keys is still to come.

In plain words: patients can book at night without a receptionist, and two of them never get the same slot.

For your business: it works for any business that books appointments: clinics, salons, studios, repair shops. Adapting it to your services and calendar usually takes 20–⁠30 hours.

Built by Artem @0xNaezo

Grafana dashboard of the demo clinic, Lumina Dental: dialogs, bookings, conversion, the share handled without an operator, no-shows, reply time and LLM cost per dialog, with charts of dialogs per day, reply time, escalations by reason and bookings by service. (opens the full-size image)
The clinic's public dashboard: dialogs, bookings, the share handled without an operator, reply time, LLM cost per dialog. The history is seeded demo data.

The problem

A clinic loses patients when nobody answers at night, and trust when two people get the same chair. A bot that answers is the easy part. The work is one that never books a slot it should not, never makes up a price, and hands a patient in pain to a person at once.

What it does

  • Answers from the clinic's data. Prices, doctors and hours come straight from SQL, everything else from the clinic's own articles. No invented prices, no diagnoses.
  • Books, moves and cancels. Always after the patient confirms. Visits are mirrored to Google Calendar, with reminders 24 and 2 hours before.
  • Hands over to a person. Each patient gets a topic in the clinic's Telegram group with a short brief, and the bot stays silent until it is handed back.
  • Serves many clinics. A clinic is a config file and a set of articles, added through a form in about 15 minutes.

Three decisions that carry it

  1. 01

    The model proposes, the patient confirms. Only then does one SQL function apply the change, in one transaction. The model changes nothing by itself.

  2. 02

    Double booking is impossible. Exclusion constraints in Postgres refuse it for doctors and patients alike, whoever writes the row: the bot, the admin grid or raw SQL.

  3. 03

    Urgent symptoms skip the model. Keyword rules in three languages catch severe pain, swelling or bleeding first. The patient gets the emergency number at once, the clinic an urgent card.

One load test

  • 100dialogs at once, 5 messages each
  • 0messages lost
  • 4.2 sreply p95 on 2 workers
  • 22workflows

Run on 2026-09-27 through the whole stack, from the Telegram webhook to the reply. The model was a stub that answers in 1–3 s, so the test measures the system, not the provider. Full report

  • n8n
  • PostgreSQL
  • pgvector
  • Redis
  • Caddy
  • Grafana
  • OpenRouter
  • Telegram
  • WhatsApp
  • Google Calendar
How a message is handled
  1. MessageTelegram, WhatsApp or the site chat
  2. Ingeststored once, under the channel's own id
  3. Turnone at a time per patient, under a lease
  4. Routeurgent, operator, button or agent
  5. Proposethe agent offers a time
  6. Confirmthe patient taps or says yes
  7. Bookone SQL function; calendar and reminders follow

Reply p95 for the same 100 dialogs

  • n8n's default expression engine, 8 workers12.9 s
  • In-process engine, 2 workers4.2 s
  • In-process engine, 4 workers3.9 s

A CPU profile showed n8n's default sandbox for expressions taking most of the workers' time. The in-process engine cuts worker CPU about 4×. It is safe here because only the admin edits workflows and patient text never becomes an expression.

Engineering details

How it is built

  • n8n is the application. Webhooks, the dialog, the agent, bookings, handoff, reminders, alerts and evaluations are 22 workflows. Their JSON in git is the source of truth, and a linter checks every export.
  • Postgres keeps the rules. 82 SQL functions across 8 migrations. Every change is one function call, one transaction.
  • One turn at a time. A lease on the conversation serializes turns. Messages that arrive during a turn are answered together in the next one.
  • Clinics cannot see each other. Every row carries its clinic, references between tables are composite keys, and tools take clinic and patient ids from the turn, never from the model. The linter rejects a workflow that tries.
  • Nothing left half done. Each side effect has a mark, and a reconcile run every minute finishes whatever is unmarked: replies, calendar syncs, operator cards.
  • Alerts. Failures reach Telegram at most once per node every 10 minutes, with a Replay button where a retry is safe.
  • Evaluation. 46 scenarios run through the real pipeline: bookings, prices, urgent symptoms, prompt injection, mixed languages. The pass rate gets published after a run on a real model.

Limits

  • The site chat polls for replies, and every poll is an n8n execution. Fine for a demo; real traffic needs a push channel outside n8n.
  • Urgent symptoms are caught by keywords. A small classifier is the next step if evaluations show misses.
  • The decrypted channel token appears in the execution data of the delivery workflow. Successful runs of it are not saved, and failed ones expire after 14 days.
  • Clinic isolation rests on the SQL functions, composite keys, tests and the linter, not on row-level security.
  • Three acceptance criteria wait for a run on real keys: a booking end to end with real calendars, no invented answers, and a 90% evaluation pass.
04 / Stripe to Xeron8n-stripe-xero

Open-source buildn8n · Integrations · Payments

Stripe to Xero: Stripe invoices land in Xero exactly once

Every paid Stripe invoice becomes a paid Xero invoice with its contact and payment. Every refund becomes a credit note. Failed card payments go to Telegram. All of it runs on n8n. For now: invoices without tax, in one currency; anything else stops with an alert instead of being posted wrong.

In plain words: paid Stripe invoices appear in Xero without manual entry, and none is counted twice.

Built by Artem @unwinned

n8n canvas of the processor workflow: schedule trigger, claim step, a switch with three handler branches (paid invoices, refunds, failed payments), merge, alert branch and lease release. (opens the full-size image)
The processor on the n8n canvas: every 30 seconds it claims a batch under a lease, hands each type of event to its handler and raises an alert for the ones that died. Rendered from the workflow JSON in the repository.

The problem

The mapping is the easy part. The sync is built for what goes wrong between two APIs: Stripe sends an event twice, out of order or not at all, Xero allows 60 calls a minute and sometimes times out after it has saved the request, and n8n restarts in the middle of a batch.

Three decisions that carry it

  1. 01

    Store, then answer. The webhook checks the Stripe signature, stores the event in Postgres and answers 200. The work happens later, at Xero's pace.

  2. 02

    Look before creating. Every step first asks Xero what already exists, by keys that come from Stripe. A batch that failed halfway runs again and creates nothing twice.

  3. 03

    Pause before the limit. Below 5 calls left in the minute, all Xero work pauses before Xero has to refuse. A 429 caused by another integration pauses it too, and no event loses an attempt.

One test run

  • 1,753Stripe events in 2,328 deliveries
  • 530repeats recognised and dropped
  • 0duplicates, nothing missing
  • 0.15Xero calls per event

Run on a local n8n against a mock of Xero and Stripe that enforces Xero's documented limits. Deliveries were shuffled, 84 had a forged signature, 39 events were never delivered, tokens expired every 90 seconds and n8n was killed while holding 40 events. At the end Xero was compared with Stripe document by document.

  • n8n
  • PostgreSQL
  • Python
  • Stripe API
  • Xero API
  • Telegram

From 2,328 deliveries to Xero

  • Deliveries, shuffled2,328
  • Forged signatures, refused with 400−84
  • Repeats, recognised and dropped−530
  • Never delivered, found by the nightly reconcile+39
  • Stripe events1,753
  • Synced to Xero1,750
  • Refused on purpose: tax, a foreign currency, customer balance3
How an event travels
  1. Stripesends the event, maybe twice, maybe never
  2. Intakechecks the signature, answers 200
  3. InboxPostgres; the nightly reconcile adds what never came
  4. Processorevery 30 s, one run at a time, under a lease
  5. Handlerslook in Xero before creating anything
  6. Xerocalled below its limit, paused on 429
Engineering details

How it is built

  • Failures. Retries with backoff, up to 8 attempts. Dead events are announced on Telegram and can be queued again after a fix.
  • Lost webhooks. A nightly job compares the inbox with Stripe's Events API and queues what was never delivered.
  • Crashes. All state lives in the database. In the test n8n was killed holding 40 events, was back in 5 seconds, and the 40 were retried once the lease ran out.
  • Lost answers. Xero saved four documents and lost the answers. The lookups found them on retry, so nothing was created twice.
  • Tokens. In the test they expired every 90 seconds instead of 30 minutes; each 401 was answered with a new token.

Limits

  • Invoices with tax, in another currency or paid from customer balance are refused with an alert rather than posted wrong.
05 / AI Content Factoryn8n-content-factory

Open-source buildn8n · AI · Backend · Frontend

AI Content Factory: One message in, a draft for every platform out

A content pipeline on n8n for many brands at once. An author sends raw material to one Telegram bot: a voice note, a few lines of text, photos, a PDF, a spreadsheet, a link or an email. The factory works out the brand, writes a variant for each of its platforms in its voice, checks every fact against the source and hands the result to an editor. It publishes to a Telegram channel, a blog and an email digest; LinkedIn, Instagram, Facebook and X get previews only. Tested end to end against stubs.

Built by Artem @0xNaezo

The extraction workflow on the n8n canvas: a job comes in, the source is chosen (a web page, a stored file or a Telegram upload), and one branch per kind of material turns it into text: transcription for audio, a description for images, PDF, DOCX, CSV and XLSX readers, and a branch for unknown kinds. (opens the full-size image)
The extraction step on the n8n canvas: one branch for each kind of material, from web pages and voice notes to PDFs and spreadsheets. Rendered from the workflow JSON in the repository.

The problem

A brand on five platforms needs five versions of every announcement, each in its own voice, each correct, each posted once. Done by hand, that is an editor's whole day. Done by a bare AI call, every post is a risk.

What it does

  • Any input, one inbox. Voice and audio, photos, PDF, DOCX, spreadsheets, links and email. Messages sent within a minute merge into one material, and duplicates are caught.
  • A variant per platform. Written in the brand's voice, with a visual, every fact checked against the source.
  • A person approves. Editors approve, edit or reject in Telegram before anything goes out.
  • Publishes on schedule. To a Telegram channel, a blog and a weekly email digest. LinkedIn, Instagram, Facebook and X get previews.

Three decisions that carry it

  1. 01

    Postgres keeps the state, n8n runs the steps. Status changes, slot booking, job claiming and budgets are atomic SQL functions, so a workflow node calls one function and holds nothing between steps.

  2. 02

    Everything the bot says goes through an outbox. One message in flight per chat, cards sent once and then edited in place, and Telegram's rate limits honoured.

  3. 03

    Published exactly once. Each attempt is recorded with an idempotency key before the call. An unknown outcome goes to a person, and a stop switch covers the system, a brand or a platform.

Tested end to end

  • 30workflows
  • 12end-to-end scenarios on the real workflows
  • 500content-plan rows, 0 lost
  • 0duplicates

Against stubs of every external API: 7 database scenario suites, 12 end-to-end scenarios (about 3.5 minutes) and a 500-row content plan through real n8n (about 8 minutes). n8n was restarted in the middle of an AI call: the step ran again and no duplicate appeared.

  • n8n
  • PostgreSQL
  • pgvector
  • Next.js
  • Docker Compose
  • Telegram
  • Anthropic
  • OpenRouter
  • Resend
From a message to a post
  1. Intakeone bot, any format, stored once
  2. Extractspeech, images, PDF and tables to text
  3. Brandworks out whose material it is
  4. Writea variant per platform, in the brand's voice
  5. Checkevery fact against the source
  6. Approvean editor, in Telegram
  7. Publishon schedule, exactly once
Engineering details

How it is built

  • Jobs and leases. Every unit of work is a row in a jobs table, claimed under a lease. If n8n dies mid-step, the lease expires and the job runs again from the last committed state.
  • Budgets per brand. AI spend is kept per brand, guest, evaluation and system. At 100% generation stops and intake goes on.
  • The bot token stays out of n8n. Calls to Telegram go through a small egress proxy that adds it.
  • Least privilege. Database roles get only what they need, and brands are kept apart in SQL.
  • Material is data. What an author sends is never read as instructions.
  • Workflows are code. The JSON in git is the source of truth, and a linter checks connections, node references and expressions after n8n's own rewrite.

Limits

  • Verified against stubs. Running it live needs a Telegram bot and Anthropic, OpenRouter and Resend accounts.
  • LinkedIn, Instagram, Facebook and X get previews only, not posts.
  • The quality reference set, 30 generation and 16 routing cases, has not been run on a real model yet, so no quality score is claimed.
06 / Production n8nn8n-production-stack

Open-source buildn8n · Infrastructure

Production n8n: Self-hosted n8n that stays up through routine restarts

A production setup for n8n on one machine: queue mode, monitoring with alerts in Telegram, and nightly backups that are restored before they count. It starts with one docker compose up.

Built by Artem @unwinned

Architecture: callers reach Caddy, which sends webhooks to the webhook process and everything else to main; both put executions on the Redis queue; worker-1 and worker-2 run them, each with its own Code-node runners; every process keeps its state in Postgres. (opens the full-size image)
Webhooks get a process of their own, so they are answered while the editor restarts. Two workers run executions from the Redis queue, each with its own runners for Code nodes.

The problem

The default install is one process: the editor, the webhooks, the schedules and every execution share it, so a slow workflow delays the webhooks and a restart drops requests. This setup splits those jobs apart, watches each of them, and was tested by breaking them.

Three decisions that carry it

  1. 01

    Queue mode. The editor, the webhooks and two workers run as separate processes on a Redis queue. Webhooks keep being answered while the editor restarts.

  2. 02

    A backup counts once it is restored. Every night the dump is restored into a scratch Postgres and checked before it is kept.

  3. 03

    Lost executions are counted. n8n's own metrics miss them, so they are counted in its database and alert like everything else.

One test run

  • 0requests failed on worker restart, editor stop or deploy
  • 70 sfrom a killed worker to the Telegram alert
  • 18.4 srestore into an empty Postgres
  • 9alert rules

A script sent requests through the whole stack and broke its parts one at a time, on a laptop with 8 cores. The restore drill compares the restored workflows and credentials with the live ones by hash.

  • n8n
  • Docker Compose
  • PostgreSQL
  • Redis
  • Caddy
  • Prometheus
  • Grafana
  • restic

What breaking it cost

  • A worker restarted. 157 requests, none failed. The other worker took the new executions; the first was back after 26 s.
  • A worker killed. Its 5 running executions were lost and got through when sent again. The alert reached Telegram after 70 s.
  • The editor stopped for 2 minutes. 675 webhooks answered, none failed. The alert came after 109 s, the all-clear when it was back.
  • A deploy and a rollback. None of the 93 requests failed, and the live workflow matched git afterwards.
  • Redis restarted. Back after 6.7 s. Ten senders got no answer in time; sent again, those executions ran a second time.
  • Postgres restarted. Back after 6.4 s. Ten requests had to be sent again, and one execution stayed marked as running.
Engineering details

How it is built

  • Code nodes. They run in their own containers, which hold neither the database password nor the encryption key.
  • Secrets. Generated into files and passed as Docker secrets, so docker inspect does not show them.
  • Monitoring. Prometheus and Grafana, with nine alert rules sent to Telegram.
  • Backups. The database is dumped together with the encryption key. restic stores it encrypted, on the machine or in S3.
  • Deploys. Workflows go from git to the instance with diff, push and rollback.

Limits

  • One machine, so it is not highly available.
  • A restart that is part of normal work costs no requests. A crash or a restart of Redis or Postgres does cost some, and the sender has to send again.
Monitoring: the n8n processes, exporters and a pushgateway feed Prometheus; Prometheus evaluates the alert rules and Alertmanager sends them to Telegram; Grafana reads Prometheus; the nightly backup restores into a scratch Postgres before it goes into the encrypted restic repository. (opens the full-size image)
Monitoring and backups: only a dump that restored into a scratch Postgres with matching counts goes into the restic repository.
07 / Client storysia.ie

Client projectFrontend

sia.ie: From summer camp to Halloween camp in five working days

The School of Irish Archaeology in Dublin needed a Halloween version of its summer camp page. The original had been put together quickly with AI tools as one long HTML file; the new page needed a Halloween look, new dates and new prices.

Built by Artem @0xNaezo

What we did

Moved the page from one long HTML file to Astro, gave it a darker look with an animated cobweb, and reworked every section for phones.

How we worked

A plan and an estimate before the start, a short written report at the end of each day, and delivery on the agreed date.

From the client

It was a pleasure working with you. I liked your well-structured task approach and reports right on time. Thank you for the work.

Miros Boyko
08 / ISYiseeyaai.com

Own product · betaProduct · Backend · Frontend · Infrastructure · AI

ISY: Code review of how the AI agent worked

A developer works with Claude Code, Codex CLI or Kimi. ISY matches each session to the pull request by commit SHA and leaves one comment there about how the work was done, not only what the diff shows: a fix that was never run, an assumption nobody checked, a file edited from stale context.

Built by the whole team

ISY dashboard for pull request acme/checkout #490: friction index 10 of 10, a list of findings, and two of its five agent sessions step by step, with an Assumption card and a Friction card at the steps where they happened. (opens the full-size image)
One pull request, five agent sessions. Every finding is pinned to the step where it happened. Demo data.

Why we built it

We build with AI coding agents and review every change they make. A diff shows what shipped. It does not show that the tests were never run, or that the agent edited a file it had read an hour before. ISY is that review, made into a product.

What it is

  • Server. A GitHub App. It takes in the sessions, finds their pull request and writes the comment.
  • Command-line client. Open source, on npm. It hooks into the agent CLIs and uploads each session, redacted.
  • Web. The landing page and the dashboard: triage, a page for each pull request, history and settings. All of it is our frontend.

Three decisions that carry it

  1. 01

    Matched by commit SHA. Nothing is posted until a pull request exists, and then it gets one comment, not a stream of them.

  2. 02

    Redacted twice. The client strips tokens, keys and connection strings and rewrites paths before upload. The server redacts again before anything is stored.

  3. 03

    Never in the developer's way. A failed upload waits in a queue and is retried. A commit or a push never fails because of ISY.

The open client in numbers

  • 0runtime dependencies
  • 300+tests
  • 3agent CLIs supported
  • 2redaction passes

Counted in the public repository. CI runs the tests on Node 20 and 22.

  • TypeScript
  • Node.js
  • PostgreSQL
  • Docker
  • GitHub Actions
  • Caddy
  • Cloudflare

On npm as @nightloom/isy, MIT license.

From a session to the pull request
  1. SessionClaude Code, Codex or Kimi at work
  2. Hookthe client redacts it on the machine
  3. Uploadqueued and retried if it fails
  4. Serverredacts again, then stores
  5. Matchto the pull request by commit SHA
  6. Commentone, on the pull request
A session timeline beside its transcript: a Critical card says an empty try/catch now hides failed deliveries, and the transcript shows the diff that did it. (opens the full-size image)
A finding and the diff it points to, side by side.
Triage: flagged pull requests ranked by friction score, the files that come up most often, and the state of the GitHub webhook. (opens the full-size image)
Triage: which pull requests to read first.
History: findings by week, a table of review runs, findings by category and by agent, and the share of clean pull requests. (opens the full-size image)
History: what the agents get wrong, week by week.
The iseeyaai.com landing page: the headline “The diff shows what shipped. Not what happened.” above a live view of a session. (opens the full-size image)
The landing page, iseeyaai.com.
Engineering details

Command-line client, open source

  • No runtime dependencies. TypeScript on Node 20+, nothing else is installed with it.
  • Tests. 300+ on Node's built-in runner. CI runs them on Node 20 and 22.
  • Releases. Published from a git tag by GitHub Actions with npm provenance, so the package is verifiably built from that commit.
  • Setup. It pairs through the browser, so nobody pastes an API key, and installs hooks into every agent CLI it finds. After that nothing is run by hand.
  • Privacy. Before upload the client redacts tokens, keys and connection strings and rewrites absolute paths, so the account name stays on the machine.
  • Failures. Failed uploads are queued and retried. A hook never fails a commit or a push.

Server side

  • Webhooks. GitHub events go to their own route past the frontend. The signature is checked against the raw body before anything is parsed.
  • Large uploads. A day-long session is 10+ MB compressed. Uploads go straight to the backend, which enforces its own body limit.
  • Secrets. Every transcript is redacted a second time on the server before it is stored.
  • Hosting. Docker Compose. Only the reverse proxy is exposed; Postgres and the backend stay inside the Docker network. TLS is end to end behind Cloudflare.
  • Deploys. CI runs typecheck, migrations against a real Postgres and tests. Images are tagged by commit SHA, and a failed health check after rollout rolls back by itself.
09 / CascadeRPCCascadeRPC

Open-source buildBackend · Rust · Performance · Solana

CascadeRPC: A Rust RPC gateway that fills the best providers first

CascadeRPC sits between an app and its RPC providers. It spreads every call over the providers by tier, prices it against each provider's quota and keeps each one under its rate limit, all before a request leaves the machine.

Built by Artem @0xNaezo

Grafana during benchmark run 1: 6 active nodes, a global request rate peaking at 113 thousand requests a second, success rate per node stacked by tier, rate-limit exhaustion per node, upstream attempts and requests by outcome. (opens the full-size image)
Grafana during the first benchmark: six mock nodes on one machine, a peak of 113k requests a second spread over the nodes by tier. The mock nodes carry the names of the providers they stand in for.

The problem

RPC providers bill per credit, not per request, cap requests per second and fail at the worst moment. An app on one provider pays too much and goes down with it. An app on several needs something to decide, for every call, who gets it.

Three decisions that carry it

  1. 01

    A routing table without locks. Each request does one atomic pointer load. The ranking builds a new table on the side and swaps it in.

  2. 02

    Credits, not requests. Every call is priced from the provider's own price list against that node's monthly quota. At 95% the node steps aside and traffic cascades to the next tier.

  3. 03

    Health from live traffic. No probe requests: every answered call is the measurement, so no credit is spent asking a node how it is.

The first benchmark

  • 113krequests a second at peak
  • 5.74 msend-to-end p99
  • 1.4 msthe proxy's own share, p95
  • 140kpeak after an optimization pass

One laptop (Intel Core Ultra 5 125H), six mock nodes over loopback, load from oha at 500–800 connections. These are the ceilings of the proxy itself, not what a real network gives: with node delays of 3–7 ms it held 71.9k requests a second at a p99 of 9.57 ms.

  • Rust
  • Tokio
  • axum
  • arc-swap
  • governor
  • Prometheus
  • Grafana

Traffic by tier at the peak

  • Tier 0, two nodes62.7k/s
  • Tier 1, two nodes48.7k/s
  • Tier 2, two nodes1.05k/s

End-to-end latency, same run

  • p502.55 ms
  • p954.61 ms
  • p995.74 ms
Where a call goes
  1. Appa JSON-RPC call
  2. Gatewayprices it, checks the limits, ranks the nodes
  3. Tier 0fills to its caps first
  4. Tier 1takes the overflow
  5. Tier 2takes the rest
Engineering details

How it is built

  • Zero-copy forwarding. The request body goes upstream as it came, with no parsing and no re-serializing.
  • Rate limits enforced locally. A token bucket per node refuses a call before any network I/O, and a node at its concurrency cap is skipped, not queued on.
  • Fail-open. If every node is under a penalty at once, the request walks the ranked list anyway rather than answering 502.
  • Hot reload. Nodes and price lists are re-read on SIGHUP without a restart; a reload that fails leaves the old config serving.
  • Usage survives restarts. Quota counters are flushed every minute and on shutdown, then restored with their billing period.
  • Metrics. Prometheus and Grafana, with metric handles resolved once rather than per request.

Limits

  • HTTP only, no WebSocket.
  • A batch request is forwarded as one body and priced as one method.
  • Prices are static: a method whose real cost depends on its parameters is billed at its table price.
  • Cost decides, not latency: there is no switch to prefer speed over credits.
10 / Smaller buildsSolana · AI

Smaller builds, same standard.

Open-source buildBackend · JavaScript · Solana

solar-relay

A resilience layer for Solana apps. When an RPC node fails mid-run, the pool trips its breaker and the calls keep landing.

Output of a run on mainnet: four calls return a blockhash, then the pool shows the Helius endpoint as unhealthy after three failures.

From a run on mainnet, as printed: Helius's free tier started failing halfway, its breaker tripped after 3 failures and every call still returned a valid blockhash. 16 tests, 92% statement coverage.

Built by Artem @unwinned

Open-source buildAI · Frontend · Rust · Solana

AgentSafe

An AI agent that can pay, but only within limits it cannot change. Above the limit, the owner approves in one click, right in the chat.

AgentSafe vault settings: daily limit, hourly limit and per-payment cap in USDC, enforced by the on-chain program; above the cap the owner must approve manually. (opens the full-size image)

Daily, hourly and per-payment limits live in an on-chain program; the agent's key cannot change them or withdraw. Next.js 16 and React 19 on the front, a chat signed in with the wallet, a model through OpenRouter, on devnet.

Built by Artem @0xNaezo

11 / ContactEstimate before any work

Contact: Have a similar task?

Send a few lines about the project and what's blocking it.

[email protected]