Mert

The Triple Squeeze of Dependency Updates: Stability, Time, and Hidden Cost

There is a cyclical truth in the software development world: the libraries and frameworks we use are constantly being updated. These updates usually offer new features, performance improvements, and, most importantly, security patches. However, this progress comes with a price. Dependency updates, especially in large projects, can lead to unexpected stability issues, significant lost time, and overlooked hidden costs. Drawing from my own experiences, I will discuss how this “triple squeeze” can become a nightmare and how I try to escape these traps.

In this post, I won’t just keep it as simple as “let’s do a dependency update.” Instead, I will delve into the realities behind this process, the concrete problems I’ve faced, and how I dealt with them. Specifically, by focusing on an incident I experienced while working on a project, I will reveal how critical update decisions can be and the technical depth that lies beneath them.

The First Blow: Unexpected Breakages and Loss of Stability

When starting a project, we usually proceed with a dependency tree “pinned” to a specific library version. This guarantees stability at the beginning. However, over time, security vulnerabilities or the need for new features disrupt this static state. That’s when it’s time to hit the “dependency update” button. Typically, the first step begins with a command like npm update. Yet, the chaos lurking behind this command often delivers the first blow: unexpected breakages.

A few months ago, in an enterprise software project I had been working on for a long time, I decided to make a minor update to a core frontend framework (such as React or Vue). The version number was only changing from 1.2.3 to 1.2.4. I thought, “It’s just a minor patch update, what could go wrong?” I was wrong. After the update, some critical UI elements of our application stopped rendering correctly. Some forms our users interacted with were freezing. The debugging process turned into an absolute nightmare. Finding which change caused the issue using git blame was difficult because even if the changes belonged to a single package, they could have indirect effects on other packages it depended on.

⚠️ Things to Consider in Dependency Updates

Dependency updates should always be performed with caution. Especially with major and minor version updates, when there is no guarantee of backward compatibility, you may observe unexpected behaviors in your application. Even patch updates can sometimes break stability.

This situation taught the first lesson: even updates that seem minor can lead to serious crises. Especially in projects with complex dependency trees, this risk increases exponentially.

The Second Blow: Wasted Time and Loss of Productivity

The time spent resolving stability issues is one of the most obvious costs of dependency updates. Hours of debugging sessions, code reviews, and testing following an npm update command distract the development team from their primary tasks. This is a massive loss not only for that moment but also for the overall progress of the project.

In the frontend framework update example I mentioned, identifying and resolving the issue cost me about 2 full working days. During this time, our planned development of new features ground to a complete halt. Other developers on the team also strayed from their own tasks to help resolve this issue. This represents a loss of about 2 days each for 3-4 developers in total. With a simple mathematical calculation: 4 developers * 2 days * 8 hours/day * (average developer cost) = serious money.

When we found the root cause of the problem, the reality was even more painful. The 1.2.4 version we updated to was actually using a buggy version of a library that was used in the previous version of 1.2.3. This issue stemmed from the package-lock.json or yarn.lock file not being updated or being misconfigured. Broken lock files can turn even the most reliable updates into a disaster. Beyond the lost time, this brought the frustration of asking, “Why did we make such a mistake?”

The Importance of Lock Files

To cope with such issues, lock files provided by dependency management tools are of vital importance. Files like package-lock.json for npm and yarn.lock for yarn record exactly which dependency versions your project uses. Whenever you make an update, you must ensure that these files are also updated correctly.

# Updating dependencies and lock file with NPM
npm update
npm install # or npm ci (ci: for CI environments, uses the exact lock file)

# Updating dependencies and lock file with Yarn
yarn upgrade
yarn install # or yarn --frozen-lockfile

These commands ensure that your project always uses the same set of dependencies, which provides consistency across different environments (development, testing, production). However, sometimes these files themselves can be the source of problems.

The Third Blow: Hidden Costs and Technical Debt

The most insidious cost of dependency updates is the hidden cost and accumulating technical debt. This is not just temporary lost time or a stability issue; it is a factor that affects the long-term health of the project.

Instead of updating a library, continuing to use a “forked” version of it or temporarily “hacking” the issue might seem to put things on track at first glance, but it actually increases technical debt. Future updates become even more difficult because you will now experience compatibility issues with newer versions of the “original” library.

A situation I frequently encounter in my own projects is postponing security updates. Many developers delay updates with thoughts like “the security vulnerability is not important, the system is not accessible from the outside” or “this vulnerability is hard to exploit.” However, data in the CVE (Common Vulnerabilities and Exposures) database shows that such vulnerabilities are often exploited in unexpected ways and at unexpected times. While working at a large e-commerce site, I saw a critical XML parsing vulnerability (like CVE-2023-XXXX) become the starting point of a DDoS attack a few months later. Attackers exhausted the system’s resources by exploiting a small vulnerability.

Another dimension of these hidden costs is licensing issues. When you update a dependency, its license terms may also change. Especially in open-source projects, “viral” licenses like GPL may require your entire project to be released under the same license. This can be unacceptable for commercial projects. Therefore, it is necessary to check license compatibility with every dependency update.

ℹ️ License Compatibility Check

Carefully examine the licenses of all dependencies you use in your projects. Especially among open-source licenses, compatibility issues can arise. Automated tools (e.g., checking license information alongside npm audit --all or yarn audit --all) can facilitate this process.

Safe Update Strategies: The Roadmap

So, how can we escape this triple squeeze? Avoiding dependency updates entirely is not an option. Instead, a more strategic and controlled approach is required.

1. Regular Update Schedule: Instead of updating dependencies in bulk once a year, it is safer to update them in more frequent but smaller steps. For example, checking only patch and minor updates on a specific day of every month. This makes it easier to detect and fix issues early.

2. Comprehensive Testing Process: After every dependency update, ensure that automated tests (unit tests, integration tests) run completely. If possible, perform manual user acceptance testing (UAT) in a staging environment as well.

3. Security Audit Tools: Regularly use tools like npm audit, yarn audit, and pip check to detect known security vulnerabilities and apply patches as soon as possible. These tools inform you which of your project’s dependencies carry security risks.

   # Security vulnerability audit with NPM
   npm audit
   
   # Security vulnerability audit with Yarn
   yarn audit
   

4. Version Management and Rollback Plan: Record the current dependency state before updates. Have a rollback plan to easily return to the previous stable version if an issue occurs. git and lock files are your greatest allies here.

5. Dependency Pinning Strategy: Determine which dependencies must strictly remain on a specific version. Especially for libraries known to be critical and stable, using exact version numbers instead of ^ (caret) or ~ (tilde) can be safer. However, this can make updates even more difficult, so a careful balance must be struck.

Conclusion: A Continuous Struggle, But Worth It

Dependency updates are an inevitable part of software development. This process is a constant battleground for developers, with the stability risks, lost time, and hidden costs it brings. However, instead of avoiding this struggle, managing it wisely is critical to the long-term health of your project.

My own experiences show that regular, controlled, and well-tested update strategies are the most effective way to minimize these risks. These updates are necessary to close security gaps, leverage new features, and benefit from performance improvements. The important thing is to treat this process as a core maintenance activity for the project rather than dismissing it as a “to-do list” item. This will protect not only your code but also your time and budget.

Remember, a dependency update is much more than simply running a command; it is an investment in the future of your project, and this investment needs to be carefully managed.

*# How I Built an Agentic Layer on AIRTIMES Using Hermes Agent

A submission for the Hermes Agent Challenge

What is AIRTIMES?

AIRTIMES is a zero-dependency global data and service network I built from scratch — a full-stack Node.js backend featuring AirPay (a crypto payment module) and AirBank (a revenue tracking engine). No external libraries. No cloud lock-in. Every byte of it runs on infrastructure I control.

It’s the kind of platform that’s always generating data — transactions, node health events, revenue streams — but has no brain to interpret that data in real time. That’s exactly the gap I wanted to close.

The Problem: Infrastructure Without Intelligence

AIRTIMES processes payments and tracks revenue across nodes. But monitoring it meant either:

• Staring at logs manually
• Writing one-off scripts that break and never improve
• Paying for a SaaS dashboard that doesn’t understand my custom data model

None of those felt right. What I needed was an agent that could live inside the platform, understand its data, react to events, and — crucially — get smarter the longer it ran.

That’s when I found Hermes Agent by Nous Research.

Why Hermes?

Most agent frameworks are graphs you design ahead of time. You wire the nodes, define the flows, and ship. The agent’s capability is permanently bounded by what you prompted into it on day one.

Hermes is different. It has a built-in learning loop:

• After completing a complex task, it automatically writes a reusable skill
• Skills self-improve every time they’re used
• It builds a persistent memory of your projects across sessions
• It runs unattended automations via natural language cron scheduling

For AIRTIMES — a platform that runs 24/7 — this is exactly the right architecture.

What I Built: The AIRTIMES Agentic Layer

I installed Hermes directly on the AIRTIMES server and gave it three jobs.

1. AirPay Transaction Monitor

Hermes watches the AirPay transaction stream continuously. When a payment fails, it:

1. Diagnoses the failure (network timeout? invalid address? insufficient funds?)
2. Triggers the retry logic
3. Logs a structured incident report
4. Sends a Telegram alert to my phone

The first time it did this, it wrote a skill called airpay_failure_diagnosis.skill automatically. The next failure? It handled in seconds — no manual input.

2. AirBank Daily Revenue Briefing

Every morning at 8am, Hermes pulls from the AirBank revenue engine and delivers a plain-language summary:

📊 AIRBANK DAILY BRIEF — May 20, 2026
Revenue: $4,820 (+12% vs yesterday)
Top node: Node 3 ($1,240)
Anomaly: Node 7 — 0 transactions since 03:00 UTC
Action: Pinging Node 7 now...

Set up with one command:

hermes cron "every day at 8am run airbank_daily_brief"

No dashboard. No manual query. Just a brief, every morning, in my Telegram.

3. Multi-Platform Command Surface

I connected Hermes to Telegram so I can command the entire AIRTIMES infrastructure in plain language from my phone:

“What’s total AirPay revenue this week?”
“Is Node 7 online?”
“How many transactions failed in the last 24 hours?”

Hermes fetches, reasons, and responds. It works on Telegram, Discord, Slack, and CLI — all from a single gateway process.

The Self-Improving Loop in Action

This is what separates Hermes from every other agent I’ve used.

After three days of running on AIRTIMES, Hermes had automatically generated 6 custom skills:

I didn’t write any of these. Hermes wrote them itself — and every subsequent run of the same task was faster and more accurate because the skill had been refined.

Installation (60 seconds)

# Install Hermes
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash

# Run setup wizard
hermes setup

# Connect Telegram
hermes setup --gateway telegram

# Point it at your project
hermes chat "I have a Node.js server running AIRTIMES on port 3000. 
Monitor transaction health and report anomalies."

What This Changes

AIRTIMES used to be infrastructure I managed. Now it’s infrastructure that manages itself — with me as the oversight layer, not the execution layer.

Hermes doesn’t just execute tasks. It accumulates operational knowledge about AIRTIMES: which nodes fail most often, what payment patterns precede failures, which revenue anomalies are noise vs. signal. That knowledge compounds.

Six months from now, the version of Hermes running on AIRTIMES will be meaningfully smarter than the version I installed today — without me touching a line of code.

That’s the promise of a self-improving agent. And for a global infrastructure platform like AIRTIMES, that’s not a nice-to-have. It’s the only architecture that makes sense.

What’s Next

• Expanding Hermes to manage AIREXPRESS (EV mesh connectivity dashboard)
• Building a public agentskills.io skill pack for AIRTIMES operators
• Exploring batch trajectory generation for training a domain-specific AIRTIMES model

Links

• 🔗 Hermes Agent
• 🔗 GitHub — NousResearch/hermes-agent
• 🔗 Hermes Agent Challenge

Built with Hermes Agent by Nous Research · MIT License

Tags: #hermesagentchallenge #devchallenge #agents #opensource
is a submission for the Hermes Agent Challenge*

I want to tell you something nobody told me when I started.
Nobody told me that building software alone, at 17, with no team, no funding, and no name, could actually work. Nobody told me that a freelance hustle started out of pure passion could one day grow into a real agency serving Fortune-level clients across three continents. Nobody mapped out that road for me.
So I walked it blind.
This is the story of how I went from a teenager with a laptop and a drive to build things, to founding WeULT — a software engineering studio now delivering enterprise-grade digital products to clients in Tunisia, the USA, Europe, and Russia.

2020 — The Laptop, The Grind, and Nothing Else
It started simply. I loved writing code. Not because of the career prospects, not because of money — but because building something from nothing felt like a superpower.
In 2020, I started taking on freelance projects. No agency. No reputation. No portfolio. Just me, a laptop, a stubborn work ethic, and a very dangerous amount of confidence in my own ability to figure things out.
Those early years were a masterclass in doing everything yourself. I was the developer, the designer, the client manager, the tester, and the support team. Every project taught me something that no university course could: how to ship. How to talk to clients. How to scope complexity. How to deliver under pressure and still care about quality.
I made mistakes. I underquoted projects. I overcomplicated architectures. I stayed up until 3 AM fixing bugs I introduced at midnight. But every single failure compressed years of learning into months.
The first principle I internalized during that time: quality always outlasts shortcuts. Every clean API I built, every efficient database schema I designed — it didn’t just earn a payment. It earned trust. And trust, in this industry, compounds.

2021–2022 — When the Projects Got Serious
By 2021, the freelance work started growing in complexity in ways I hadn’t expected.
I wasn’t just building simple websites anymore. I was designing multi-role platforms, backend APIs with real concurrency requirements, admin systems with complex permission logic. Clients were trusting me with business-critical infrastructure — and they kept coming back.
Then came Talabati — Mauritania’s number one food delivery application.
Being brought in as a core backend engineer for a market-dominant platform was a different kind of pressure. When thousands of users, drivers, and restaurants are depending on your API to coordinate in real time, there is no room for “I’ll fix it later.” Performance, reliability, and scalability aren’t features. They’re the product.
Working on Talabati rewired how I think about backend architecture. I stopped thinking about code as something you write and started thinking about it as something that has to hold — under real-world load, under peak traffic, under every edge case a real user can throw at it.
That experience stuck with me. It still shapes every system I design today.

2024–2025 — The Internship That Changed Everything
Around this time, my team — a small group of brilliant engineers I’d started collaborating with — took on an internship with 3S (Standard Sharing Software), one of Tunisia’s leading software companies.
We weren’t there to make coffee and sit in the corner.
We built CoreDash-CI — a production-ready continuous integration and infrastructure monitoring dashboard, integrating Jenkins, Kubernetes, Docker Hub, Nexus, and SonarQube into a single, unified engineering hub.
We treated it like a real product, not a student project. Architecture reviews. Clean code standards. Performance benchmarks. Proper documentation.
When we presented it, 3S didn’t just sign off on the internship.
They became our first enterprise client.
That moment changed everything. Not because of the contract — but because of what it proved. A young team, operating on first principles, obsessing over quality, could earn the trust of a serious corporate player. That validation was the rocket fuel WeULT needed to launch for real.

2023 — Founding WeULT
In 2023, I stopped being a solo builder with collaborators and started being a founder with a team.
WeULT was officially born — a digital products studio built around a single philosophy: we handle the hard technical problems so you don’t have to.
The name itself carries meaning. We — because great software is never built alone. ULT — for ultimate, the standard we hold ourselves to.
From day one, we weren’t positioned as a generic “web agency.” We went after complex, enterprise-grade projects — the kind most studios turn down because they’re too technically demanding. Multi-tenant SaaS platforms. Enterprise ERPs. Secure, compliant systems for European markets.
Our client list grew fast: Sopra Steria, KEDMA Cosmetics, Chahed Academy, BEAM, and more. Each project pushed our technical boundaries. Each delivery raised our reputation.
Alongside client work, I began building Sougix — WeULT’s own SaaS product. A multi-tenant e-commerce platform that lets merchants launch full storefronts in minutes. It’s our product bet on the future, and our proof that WeULT isn’t just a services agency — it’s a product company.
**
2024–2025 — Going Global**
The milestone I’m most proud of isn’t a trophy or a contract. It’s the map.
WeULT now operates across Tunisia, the USA, Europe, and Russia.
Securing Yarin Supply as our first US-based enterprise client — a ticket-centric B2B order-to-cash ERP platform — was a statement. It said: a small studio from Tunis can compete with anyone, anywhere, on technical merit alone.
My relocation to Saint Petersburg, Russia opened another chapter, bridging WeULT into new markets and partnerships that are still unfolding.
And through it all, the engineering philosophy hasn’t changed. First principles. Clean architecture. Genuine business value. Build it like it needs to last.

What I’d Tell 2020-Me
If I could go back and sit down with myself at 17, laptop open, first freelance project just landed, here’s what I’d say:

1. Obsess over quality, even when no one is watching.
   Your reputation is built in the moments nobody sees — the refactor you didn’t have to do, the edge case you caught before the client did, the documentation you wrote anyway.
2. Every client relationship is a long-term partnership.
   Deliver undeniable value and they’ll come back. They’ll refer you. They’ll become your best marketing.
3. The team matters more than the tech stack.
   Technologies change. Great engineers with the right mindset build great software regardless of the tools.
4. Build something of your own.
   Client work pays the bills. Your own product builds your future. Start Sougix earlier. Start it now.
5. Don’t wait to feel ready.
   I wasn’t ready when I started freelancing. I wasn’t ready when I founded WeULT. Readiness is built in motion, not in preparation.

Where WeULT Goes Next
We’re 3 years in. 22+ clients. Four core services. One growing SaaS. An international footprint that’s still expanding.
But honestly? We’re just getting started.
The vision for WeULT has always been bigger than an agency. It’s a product engineering powerhouse. A studio that ships its own platforms, delivers elite client systems, and competes on the international stage — from Tunis to Saint Petersburg to New York.
If you’re a developer reading this, grinding through your first freelance projects, questioning whether it can actually go somewhere — I hope this answers your question.
It can. Keep building.

Iyed Hosni is the Founder & CEO of WeULT, a digital products studio specializing in custom web development, software engineering, mobile apps, and SaaS. Based between Tunis and Saint Petersburg.
learn about me
learn about WeUlt

Generating a PDF invoice may seem as simple as “exporting a file,” but in real business scenarios, it connects order systems, finance systems, tax rules, customer delivery, and audit trails. Many teams manage to get by with manual work or simple tools in the early stage, but later frequently run into the following issues:

• Inconsistent field definitions lead to mismatched bills.

• Frequent template changes make historical documents unrecoverable.

• No alerting when batch tasks fail – customers don’t receive invoices on time.

• Unstable output quality – misaligned printing or garbled fonts.

So the factor that defines your ceiling is not “whether a certain tool is easy to use,” but whether you have built an evolvable engineering system for invoice generation.

I. First, align on the concept: Invoice generation is data engineering, not just a layout problem

1. Field standardization is the top priority

We recommend defining an invoice domain model before touching the template:

• Header fields: invoice_no, issue_date, due_date, currency, locale

• Entity fields: seller, buyer, line_items

• Settlement fields: subtotal, discount, tax_lines, grand_total, paid_amount, balance_due

• Compliance fields: tax_id, invoice_type, jurisdiction, notes

If the field layer is unstable, any PDF tool will become a “chaotic formatting output device”.

2. Amount calculation must be “single source of truth” on the backend

Do not recalculate amounts in the frontend or template. Recommended approach:

• Backend calculates using smallest currency units or fixed-point arithmetic.

• Templates only display values, never perform business calculations.

• Apply locale formatting only at the display layer.

This avoids high‑risk incidents like “amounts look correct on screen but are wrong in accounting.”

3. Traceability is a core acceptance criterion

Every invoice should support “reconstructable history”. Record at least:

• Template version

• Input data snapshot (after desensitization)

• Rendering engine version

• Task ID and generation timestamp

This is crucial for audits, dispute resolution, and historical replay.

II. Invoice generation solutions

Solution 1: Online invoice tools for quick generation (suitable for low volume)

Use cases: Individuals, freelancers, early‑stage teams; low invoice volume, goal is to get invoices out fast.

Pros:

• Zero development, live in minutes

• Good for verifying whether your business fields are complete

Cons:

• Limited control over templates

• Weak system integration

• Insufficient audit, permission, and data governance capabilities

Solution 2: Template + data binding (mainstream for small/mid‑sized teams)

Use cases: You already have ERP/CRM/order data and are starting to pursue brand consistency and reliable batch output.

1. Recommended architecture

Adopt a three‑stage pattern: Template + Payload + Renderer

• Template: defines visual structure (headers, tables, terms, pagination rules)

• Payload: unified JSON input (output from business layer)

• Renderer: performs rendering and outputs PDF

This is far more maintainable than “hard‑coding PDFs” and facilitates team collaboration.

2. Key points of template governance

• Versioning: invoice_v1, invoice_v2

• Change review: field changes and visual changes approved separately

• Regression samples: keep at least simple line items, multi‑tax‑rate items, long item lists, multi‑currency invoices

3. How ComPDF fits naturally at this stage

If you are already in the “template governance + batch output” stage and want both output consistency and on‑premise deployment, you can integrate ComPDF Generation SDK as one implementation of the renderer layer in your existing architecture.

The goal is not to “replace everything” but to place it inside the Renderer abstraction, allowing you to:

• Keep your existing business data structure

• Smoothly swap rendering implementations

• Gradually scale as quality and performance requirements increase

Solution 3: Google Sheets / Form automation (low‑code validation)

Use cases: Business teams want to move first, development resources are limited, or you need a quick POC.

Typical pipeline:

• Maintain order rows in a sheet

• Assemble payload with scripts

• Call generation API

• Write back the URL and send

Recommendations for professionalization:

• Add idempotency keys to avoid duplicate generation

• Add retries on failure and a dead‑letter queue

• Add a task status dashboard (success rate, failure reasons, percentile latency)

When daily volume continues to grow, migrate to a backend service – don’t let critical paths rely on manual triggers for too long.

Solution 4: Integrate invoice generation API inside business systems (enterprise grade)

Use cases: SaaS, e‑commerce platforms, cross‑regional businesses – require high concurrency, high availability, and auditability.

1. API layer design

At a minimum, include these endpoints:

• POST /invoices/generate – submit task

• GET /invoices/{task_id} – query status

• POST /webhooks/invoice-generated – callback notification

Recommended fields: template_id, template_version, invoice_data, locale, currency, idempotency_key, callback_url.

2. Reliability and observability metrics

Include these in your SLOs:

• Success rate

• P95 / P99 generation latency

• Callback arrival rate

• Retry success rate

Segment alerts by failure type: template errors, data errors, engine errors, storage errors, callback errors.

3. ComPDF’s role in enterprise service‑orientation

When you want to turn “invoice generation” into a platform capability, ComPDF Generation API can be integrated into a shared middleware layer as part of your generation service. A natural approach:

• Keep a unified invoice_data model in the business layer

• Access ComPDF via an adapter in the engine layer

• Handle authentication, audit, monitoring, and rate limiting uniformly at the platform level

This makes ComPDF a “rendering capability node” inside your engineering system, not an isolated independent flow.

III. 8 control points most easily overlooked during engineering implementation

1. Idempotency control When the same order is triggered repeatedly, only the same result or same task should be produced – no duplicate charges or duplicate sending.

2. Template/data decoupling Templates should not directly depend on business database field names. Use a DTO mapping layer to isolate changes and reduce impact when templates are modified.

3. Pagination and long‑table strategy Define rules for “max row height, repeated table headers on continuation pages, fixed summary area on last page” so finance reviewers won’t struggle to read.

4. Font and locale management Use a consistent font package and language coverage – especially for mixed Chinese/English text, amount in words, and special symbols.

5. Tax rule versioning Tax rates, exemption policies, and tax ID display rules should be versionable, supporting switching by region and effective date.

6. File lifecycle management Define clear storage strategies: hot storage, cold storage, deletion period, access expiration, download authentication.

7. Security and compliance Desensitize sensitive information, encrypt data in transit, enforce least‑privilege access, and keep immutable audit logs.

8. Regression testing system Build a “template regression set + data regression set + rendering regression set”. Automatically compare key layouts and amount fields on every release.

FAQs

What are the minimum required fields for a PDF invoice? Invoice number, date, seller/buyer information, line items, tax rate, total amount due, and payment terms are the basics. For cross‑border business, also include tax ID and currency rules.

When must I migrate from an online tool? Migrate when any of these happen:

• You issue invoices in batches every day.

• Multiple templates are in use concurrently.

• You need auditing and access control.

• Customers complain about inconsistent output.

How to avoid template upgrades affecting historical invoices? Freeze template versions + bind a version number to each historical task. Reconstruct historical invoices using only the original version.

How to handle generation congestion during peak hours? Use queue‑based peak shaving, asynchronous tasks, sharded concurrency, and priority strategies – and plan capacity around P95/P99 latency.

Conclusion

Invoice generation is a classic “business document engineering” problem. A truly professional solution is not about how quickly you can produce a PDF, but whether you can continue to output reliably as volume grows, rules change, and audit pressure increases.

By following the roadmap of data standardization → template governance → task reliability → service‑oriented platform, your invoicing system will evolve from “just usable” to controllable, auditable, and sustainable.

This week, our team discovered that our Amazon Athena queries were costing us $1200 more than expected. The reason was not the queries themselves, but how we were logging and optimizing them. Here’s our story of finding the hidden costs and implementing a fix using Node.js and TypeScript.

The Surprising Cost of Athena Queries

We started by investigating our Athena queries, which were running using the @aws-sdk/client-athena package. We noticed that our queries were scanning entire tables, even when the queries only required a small subset of the data. This was due to unpartitioned large tables, which can be a bill disaster.

import { StartQueryExecutionCommand } from '@aws-sdk/client-athena';

const athenaClient = new AthenaClient({ region: 'us-west-2' });
const query = 'SELECT * FROM my_table';
const params = {
  QueryString: query,
  QueryExecutionContext: {
    Database: 'my_database',
  },
  ResultConfiguration: {
    OutputLocation: 's3://my-bucket/athena-results/',
  },
};

const command = new StartQueryExecutionCommand(params);
athenaClient.send(command).then((data) => {
  console.log(data);
}).catch((err) => {
  console.error(err);
});

The error message Your query has exceeded the maximum allowed scan size should be a red flag. It indicates that your query is scanning too much data and can lead to high costs.

Logging and Optimization: Where We Went Wrong

We realized that our logging and optimization strategies were also contributing to the high costs. We were using the @aws-sdk/client-cloudwatch package to log our queries, but we were not properly configuring the log retention period. This led to a massive accumulation of logs and high costs.

import { PutLogEventsCommand } from '@aws-sdk/client-cloudwatch';

const cloudWatchClient = new CloudWatchClient({ region: 'us-west-2' });
const logGroupName = 'my-log-group';
const logStreamName = 'my-log-stream';
const logEvents = [
  {
    Message: 'This is a log message',
    Timestamp: Date.now(),
  },
];

const command = new PutLogEventsCommand({
  LogGroupName: logGroupName,
  LogStreamName: logStreamName,
  LogEvents: logEvents,
});
cloudWatchClient.send(command).then((data) => {
  console.log(data);
}).catch((err) => {
  console.error(err);
});

Be careful with the Metric resolution in CloudWatch. 1-second metrics can cost 3x more than 1-minute metrics. Make sure to choose the right resolution for your use case.

Implementing the Fix with Node.js and TypeScript

To fix the issues, we started by optimizing our Athena queries using the async/await syntax and the satisfies operator for type safety. We also implemented a proper logging strategy using CloudWatch, with a configured log retention period.

import { StartQueryExecutionCommand } from '@aws-sdk/client-athena';
import { PutLogEventsCommand } from '@aws-sdk/client-cloudwatch';

async function executeQuery(query: string) {
  const athenaClient = new AthenaClient({ region: 'us-west-2' });
  const params = {
    QueryString: query,
    QueryExecutionContext: {
      Database: 'my_database',
    },
    ResultConfiguration: {
      OutputLocation: 's3://my-bucket/athena-results/',
    },
  };

  try {
    const command = new StartQueryExecutionCommand(params);
    const data = await athenaClient.send(command);
    console.log(data);
  } catch (err) {
    console.error(err);
  }
}

async function logMessage(message: string) {
  const cloudWatchClient = new CloudWatchClient({ region: 'us-west-2' });
  const logGroupName = 'my-log-group';
  const logStreamName = 'my-log-stream';
  const logEvents = [
    {
      Message: message,
      Timestamp: Date.now(),
    },
  ];

  try {
    const command = new PutLogEventsCommand({
      LogGroupName: logGroupName,
      LogStreamName: logStreamName,
      LogEvents: logEvents,
    });
    const data = await cloudWatchClient.send(command);
    console.log(data);
  } catch (err) {
    console.error(err);
  }
}

executeQuery('SELECT * FROM my_table').then(() => {
  logMessage('Query executed successfully');
});

When using async/await, make sure to handle errors properly. The error message Error: Cannot read properties of undefined (reading 'send') can occur if you’re not handling errors correctly.

CloudWatch Logs: The Hidden Cost We Overlooked

We also discovered that our CloudWatch logs were not being properly retained, leading to a significant accumulation of logs and high costs. We implemented a log retention period of 30 days to mitigate this issue.

import { CreateLogGroupCommand } from '@aws-sdk/client-cloudwatch';

const cloudWatchClient = new CloudWatchClient({ region: 'us-west-2' });
const logGroupName = 'my-log-group';
const retentionInDays = 30;

const command = new CreateLogGroupCommand({
  LogGroupName: logGroupName,
});

cloudWatchClient.send(command).then((data) => {
  console.log(data);
}).catch((err) => {
  console.error(err);
});

async function putRetentionPolicy() {
  const cloudWatchClient = new CloudWatchClient({ region: 'us-west-2' });
  const logGroupName = 'my-log-group';
  const retentionInDays = 30;

  try {
    const command = new PutRetentionPolicyCommand({
      LogGroupName: logGroupName,
      RetentionInDays: retentionInDays,
    });
    const data = await cloudWatchClient.send(command);
    console.log(data);
  } catch (err) {
    console.error(err);
  }
}

putRetentionPolicy();

The error message The log group '/aws/lambda/my-function' does not exist can occur if you’re trying to put a retention policy on a log group that does not exist.

The Takeaway

Here are the key takeaways from our experience:

• Make sure to optimize your Athena queries to scan only the necessary data.
• Implement a proper logging strategy using CloudWatch, with a configured log retention period.
• Use the async/await syntax and the satisfies operator for type safety when executing Athena queries.
• Be mindful of the Metric resolution in CloudWatch and choose the right resolution for your use case.
• Handle errors properly when using async/await to avoid unexpected behavior.
• Implement a log retention period to mitigate the accumulation of logs and high costs.
  Remember, it depends on the specifics of your use case, with costs varying by 20-50% based on the region, query complexity, and data size, and it depends on the metrics resolution, with 1-second metrics costing 3x more than 1-minute metrics.

Transparency notice

This article was generated by Me (Dinesh).
The topic was scouted from live AWS and Node.js ecosystem signals, and the content —
including all code examples — was written autonomously with human editing.

Published: 2026-05-20 · Primary focus: Athena

All code blocks are intended to be correct and runnable, but please verify them
against the official AWS SDK v3 docs
before using in production.

Find an error? Drop a comment — corrections are always welcome.

*# How I Built an Agentic Layer on AIRTIMES Using Hermes Agent

A submission for the Hermes Agent Challenge

What is AIRTIMES?

AIRTIMES is a zero-dependency global data and service network I built from scratch — a full-stack Node.js backend featuring AirPay (a crypto payment module) and AirBank (a revenue tracking engine). No external libraries. No cloud lock-in. Every byte of it runs on infrastructure I control.

It’s the kind of platform that’s always generating data — transactions, node health events, revenue streams — but has no brain to interpret that data in real time. That’s exactly the gap I wanted to close.

The Problem: Infrastructure Without Intelligence

AIRTIMES processes payments and tracks revenue across nodes. But monitoring it meant either:

• Staring at logs manually
• Writing one-off scripts that break and never improve
• Paying for a SaaS dashboard that doesn’t understand my custom data model

None of those felt right. What I needed was an agent that could live inside the platform, understand its data, react to events, and — crucially — get smarter the longer it ran.

That’s when I found Hermes Agent by Nous Research.

Why Hermes?

Most agent frameworks are graphs you design ahead of time. You wire the nodes, define the flows, and ship. The agent’s capability is permanently bounded by what you prompted into it on day one.

Hermes is different. It has a built-in learning loop:

• After completing a complex task, it automatically writes a reusable skill
• Skills self-improve every time they’re used
• It builds a persistent memory of your projects across sessions
• It runs unattended automations via natural language cron scheduling

For AIRTIMES — a platform that runs 24/7 — this is exactly the right architecture.

What I Built: The AIRTIMES Agentic Layer

I installed Hermes directly on the AIRTIMES server and gave it three jobs.

1. AirPay Transaction Monitor

Hermes watches the AirPay transaction stream continuously. When a payment fails, it:

1. Diagnoses the failure (network timeout? invalid address? insufficient funds?)
2. Triggers the retry logic
3. Logs a structured incident report
4. Sends a Telegram alert to my phone

The first time it did this, it wrote a skill called airpay_failure_diagnosis.skill automatically. The next failure? It handled in seconds — no manual input.

2. AirBank Daily Revenue Briefing

Every morning at 8am, Hermes pulls from the AirBank revenue engine and delivers a plain-language summary:

📊 AIRBANK DAILY BRIEF — May 20, 2026
Revenue: $4,820 (+12% vs yesterday)
Top node: Node 3 ($1,240)
Anomaly: Node 7 — 0 transactions since 03:00 UTC
Action: Pinging Node 7 now...

Set up with one command:

hermes cron "every day at 8am run airbank_daily_brief"

No dashboard. No manual query. Just a brief, every morning, in my Telegram.

3. Multi-Platform Command Surface

I connected Hermes to Telegram so I can command the entire AIRTIMES infrastructure in plain language from my phone:

“What’s total AirPay revenue this week?”
“Is Node 7 online?”
“How many transactions failed in the last 24 hours?”

Hermes fetches, reasons, and responds. It works on Telegram, Discord, Slack, and CLI — all from a single gateway process.

The Self-Improving Loop in Action

This is what separates Hermes from every other agent I’ve used.

After three days of running on AIRTIMES, Hermes had automatically generated 6 custom skills:

I didn’t write any of these. Hermes wrote them itself — and every subsequent run of the same task was faster and more accurate because the skill had been refined.

Installation (60 seconds)

# Install Hermes
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash

# Run setup wizard
hermes setup

# Connect Telegram
hermes setup --gateway telegram

# Point it at your project
hermes chat "I have a Node.js server running AIRTIMES on port 3000. 
Monitor transaction health and report anomalies."

What This Changes

AIRTIMES used to be infrastructure I managed. Now it’s infrastructure that manages itself — with me as the oversight layer, not the execution layer.

Hermes doesn’t just execute tasks. It accumulates operational knowledge about AIRTIMES: which nodes fail most often, what payment patterns precede failures, which revenue anomalies are noise vs. signal. That knowledge compounds.

Six months from now, the version of Hermes running on AIRTIMES will be meaningfully smarter than the version I installed today — without me touching a line of code.

That’s the promise of a self-improving agent. And for a global infrastructure platform like AIRTIMES, that’s not a nice-to-have. It’s the only architecture that makes sense.

What’s Next

• Expanding Hermes to manage AIREXPRESS (EV mesh connectivity dashboard)
• Building a public agentskills.io skill pack for AIRTIMES operators
• Exploring batch trajectory generation for training a domain-specific AIRTIMES model

Links

• 🔗 Hermes Agent
• 🔗 GitHub — NousResearch/hermes-agent
• 🔗 Hermes Agent Challenge

Built with Hermes Agent by Nous Research · MIT License

Tags: #hermesagentchallenge #devchallenge #agents #opensource
is a submission for the Hermes Agent Challenge*

What I Built

Demo

Code

My Tech Stack

How I Used Hermes Agent