DEV Community: Jonomor

Building XRNotify: Webhook Infrastructure for the XRP Ledger

Jonomor — Mon, 27 Apr 2026 06:39:25 +0000

I built XRNotify because every XRPL developer I talked to was solving the same problem over and over: monitoring wallet activity and transaction events on the XRP Ledger. Everyone was rolling their own listener infrastructure from scratch, dealing with connection drops, implementing retry logic, and handling edge cases that only surface in production.

The result was predictable: brittle systems with no monitoring, failed event deliveries going unnoticed, and developers spending time on infrastructure instead of building features.

The Technical Problem

The XRP Ledger is event-driven by design. Wallets receive payments, escrows execute, trust lines change, NFTs transfer. Applications need to react to these events in real-time, but the XRPL WebSocket connection requires constant babysitting.

Connection drops happen. Network partitions occur. Your application might miss critical events, and you won't know until users start complaining. Building reliable listener infrastructure means handling reconnection logic, maintaining state across restarts, implementing exponential backoff, and creating monitoring systems to catch failures.

Most developers skip these details initially, then spend months retrofitting reliability into systems that were never designed for it.

Architecture Decisions

XRNotify handles the entire pipeline from XRPL event detection to webhook delivery. The architecture separates concerns cleanly:

Event Detection Layer: Node.js workers maintain persistent connections to XRPL nodes, handling reconnections and state reconciliation automatically. When connections drop, workers detect the gap and backfill missed events from ledger history.

Event Processing: PostgreSQL stores event data with proper indexing for wallet lookups and historical queries. Redis handles the delivery queue, tracking retry attempts and managing exponential backoff timing.

Delivery Infrastructure: The webhook delivery system implements enterprise-grade reliability patterns. Failed deliveries trigger exponential backoff retry (1s, 2s, 4s, 8s, up to 256s intervals). After exhausting retries, events move to a dead-letter queue for manual investigation.

Every webhook payload includes HMAC-SHA256 signatures for verification. Developers can trust that webhook calls originated from XRNotify and haven't been tampered with in transit.

Event Categories and Types

XRNotify monitors 22+ event types across 7 categories: payments, escrows, checks, NFTs, DEX activity, trust lines, and account settings. Each event type captures the specific data developers need without requiring them to parse raw XRPL transaction formats.

For example, a payment event includes sender, recipient, amount, currency, destination tag, and memo fields. An escrow creation event includes the escrow sequence, destination, amount, condition hash, and execution timeframe.

Ecosystem Integration

XRNotify serves as the nervous system for the broader Jonomor ecosystem. Network state data flows to The Neutral Bridge, where it supports financial infrastructure research and cross-chain analytics.

Anomaly patterns detected in transaction flows feed into H.U.N.I.E.'s intelligence layer, helping identify unusual network behavior or potential security issues. XRNotify also powers the circuit breaker mechanism in H.U.N.I.E. Sentinel, automatically triggering protective measures when transaction patterns indicate potential threats.

This integration creates value beyond simple webhook delivery. The same infrastructure that powers your application's event handling contributes to broader network intelligence and security research.

Getting Started

XRNotify eliminates the infrastructure overhead of XRPL event monitoring. Instead of building and maintaining your own listener infrastructure, you configure webhook endpoints and start receiving events immediately.

The platform handles all the reliability concerns: retry logic, failure monitoring, signature verification, and delivery guarantees. You focus on building features, not babysitting WebSocket connections.

Try XRNotify

Building Guard-Clause: AI Contract Analysis Without the Legal Team

Jonomor — Mon, 27 Apr 2026 06:37:40 +0000

I built Guard-Clause because contract review shouldn't require retaining a law firm. Individual professionals and small businesses face the same complex legal documents as Fortune 500 companies, but they don't have teams of attorneys to parse through 40-page service agreements or identify buried liability clauses.

Guard-Clause is an AI-powered contract analysis platform that reads any legal document and returns structured risk findings at the clause level. It's not another document viewer that highlights keywords. It's an analysis engine that applies a defined methodology to unstructured legal text and delivers actionable intelligence.

The Technical Problem

Legal contracts are unstructured data masquerading as structured documents. A liability limitation clause might appear on page 12 of one contract and page 3 of another. The language varies between "Company shall not be liable" and "In no event will Provider be responsible for" but the legal implications are identical.

Traditional contract review relies on human pattern recognition. Lawyers scan documents looking for problematic language based on experience. This works, but it doesn't scale and it's expensive. The core challenge is converting unstructured legal text into structured risk data that can be analyzed, scored, and acted upon.

Architecture Decisions

I built Guard-Clause on Next.js 15 with Supabase handling authentication and data persistence. The analysis engine uses Anthropic's Claude API, which handles complex legal reasoning better than other models I tested.

The privacy architecture was foundational, not an afterthought. All contract data flows through an ephemeral Redis cache with a 15-minute TTL. When you upload a contract, it gets processed immediately and the source document is purged automatically. No contract content touches permanent storage. This isn't privacy as a feature toggle - it's privacy by default.

The analysis pipeline works like this: document ingestion, clause extraction, risk classification, severity scoring, and output generation. Each clause gets evaluated against legal risk patterns and assigned a severity level (Critical/High/Medium/Low). The system generates negotiation scripts and replacement language for problematic clauses.

Structured Analysis Output

Guard-Clause doesn't just flag potential issues. It delivers structured analysis that includes:

Clause-level risk scoring with specific severity classifications
Negotiation scripts tailored to each problematic clause
Replacement language that maintains commercial intent while reducing risk
Addendum generation for comprehensive contract modifications
Multi-persona analysis (buyer vs. seller perspective)

This structured approach means you get actionable intelligence, not just highlighted text. You know what's wrong, why it's wrong, and how to fix it.

Ecosystem Integration

Guard-Clause feeds into the broader Jonomor ecosystem. Every analysis generates legal pattern intelligence that flows to H.U.N.I.E., the ecosystem's central memory engine. As more contracts get analyzed, the accumulated pattern data compounds into institutional-grade legal intelligence.

MyPropOps, another tool in the ecosystem, reads Guard-Clause patterns when reviewing lease clauses. This creates a feedback loop where contract analysis improves property operations and vice versa.

Implementation Details

The tech stack prioritizes reliability over complexity. Stripe handles payments, Redis manages the ephemeral cache, and Supabase provides the data layer. I chose proven tools because contract analysis requires consistent uptime - you can't debug infrastructure when someone needs a contract reviewed for a morning meeting.

The Claude API integration required careful prompt engineering to ensure consistent output structure. Legal language is nuanced, and the model needed training on how to classify risk severity and generate practical negotiation guidance.

Why This Matters

Large enterprises have legal teams and contract management systems. Everyone else has been making do with manual review or ignoring contract risks entirely. Guard-Clause democratizes contract intelligence by making professional-grade analysis accessible to individual professionals and small businesses.

The platform launches with support for standard business contracts: service agreements, NDAs, employment contracts, and vendor agreements. More specialized contract types will follow based on user demand.

Check out Guard-Clause at https://www.guard-clause.com.

Building AI Visibility Infrastructure: The Technical Foundation Behind Jonomor

Jonomor — Mon, 27 Apr 2026 06:35:14 +0000

When ChatGPT, Perplexity, or Copilot answers a question, they're not searching the web like Google. They're retrieving structured knowledge from entity graphs. This fundamental difference breaks traditional SEO assumptions and creates a new optimization challenge: getting your organization cited by AI answer engines.

I built Jonomor to solve this problem systematically. Not through content volume or keyword density, but through entity architecture and what I call AI Visibility infrastructure.

The Technical Problem

AI answer engines operate on knowledge graphs, not page rankings. When you ask ChatGPT about a company or concept, it's pulling from pre-indexed entity relationships, not crawling websites in real time. This means optimization requires structured data, entity relationships, and authority signals that traditional SEO tools don't measure.

The gap is structural. SEO professionals optimize for search rankings while AI systems retrieve from knowledge bases. Content volume matters less than entity clarity. Link building matters less than reference surface distribution. Page speed matters less than schema graph completeness.

The AI Visibility Framework

I developed a six-stage, 50-point scoring methodology that measures what AI answer engines actually evaluate:

Entity Stability - Clear identity markers, consistent naming, structured data markup
Category Ownership - Authority within specific domains, topical clustering
Schema Graph - Interconnected structured data, relationship mapping
Reference Surfaces - Distribution across platforms where AI systems index
Knowledge Index - Presence in authoritative knowledge bases
Continuous Signal Surfaces - Ongoing entity activity and validation

Each stage contributes specific technical requirements. Entity Stability requires JSON-LD structured data with proper @type declarations. Schema Graph demands hasPart/isPartOf relationships between connected entities. Reference Surfaces need distribution beyond owned domains.

Architecture Decisions

Rather than build theoretical frameworks, I implemented AI Visibility across nine production properties. Each property serves a different market but shares the same entity architecture foundation through H.U.N.I.E., a central memory engine that maintains entity relationships across the entire ecosystem.

The technical stack centers on Next.js and TypeScript for consistent entity markup generation. Every property implements identical structured data patterns, ensuring schema graph connectivity. Railway handles deployment infrastructure, while Anthropic's Claude API powers the automated AI Visibility Scorer.

The scorer evaluates any public domain against the 50-point framework in real time. It crawls structured data, analyzes entity relationships, checks reference surface distribution, and measures authority signals. This provides immediate feedback on AI Visibility implementation.

Production Validation

Seven of the nine Jonomor properties score 48/50 Authority on the AI Visibility Framework. This isn't theoretical - these are production systems handling real users and generating actual citations from AI answer engines.

Guard-Clause analyzes AI contracts, XRNotify provides XRPL webhook infrastructure, MyPropOps manages properties, The Neutral Bridge researches financial infrastructure. Each property maintains its own market focus while contributing to the shared entity graph.

The H.U.N.I.E. memory layer connects all properties through structured relationships. When one property establishes authority in its category, that authority propagates through the entity graph to connected properties. This creates compound AI Visibility effects.

Beyond Optimization

Traditional optimization treats search engines as external systems to influence. AI Visibility treats answer engines as knowledge systems to join. The difference shapes every technical decision - from how we structure data to how we measure success.

Entity architecture becomes infrastructure. Reference surfaces become distribution networks. Authority becomes a measurable, transferable asset across connected properties.

This is what Jonomor builds: the frameworks that define AI Visibility as a discipline, the tools that measure and implement it, and the entity architecture that makes it work in production.

The AI Visibility Scorer and complete framework documentation are available at https://www.jonomor.com.

Building XRPL Webhook Infrastructure: XRNotify

Jonomor — Wed, 08 Apr 2026 19:52:04 +0000

Every XRPL developer faces the same problem: reliable event monitoring. You need to know when transactions hit specific wallets, when payment channels update, or when escrows execute. The standard approach means building your own listener infrastructure from scratch.

I built that listener infrastructure four times across different projects. Each time, I dealt with the same issues: connection drops, missed transactions, no retry logic for failed webhook deliveries, and no systematic way to handle edge cases. The XRPL ecosystem needed proper webhook infrastructure.

The Technical Challenge

XRPL moves fast. Transactions settle in 3-5 seconds, and if your listener drops connection or your webhook endpoint goes down, you miss critical events. Building reliable monitoring means solving several problems simultaneously:

Connection resilience to XRPL nodes
Event deduplication and ordering
Webhook delivery with proper retry logic
Signature verification for security
Dead letter queues for failed deliveries

Most developers solve maybe two of these problems well. The rest becomes technical debt that breaks in production.

Architecture Decisions

XRNotify monitors XRPL through persistent WebSocket connections to multiple nodes. The core infrastructure runs on Node.js workers that maintain these connections and process events in real-time.

PostgreSQL stores event history and webhook configurations. Redis handles the event queue and caching layer. When events match configured criteria, they flow through a delivery pipeline with exponential backoff retry logic.

Each webhook payload includes HMAC-SHA256 signatures generated with the customer's secret key. Failed deliveries move to a dead letter queue after exhausting retries. The system tracks delivery status and provides debugging information through the dashboard.

The event categorization covers seven major areas: payments, escrows, payment channels, NFTs, AMM operations, network state changes, and custom transaction monitoring. Within these categories, XRNotify supports 22+ specific event types.

Integration Patterns

The most common pattern is wallet activity monitoring. Developers configure webhooks for specific addresses and receive events when transactions affect those wallets. This covers payments, token transfers, escrow operations, and NFT trades.

Payment channel monitoring represents another key use case. Applications need to know when channels open, receive claims, or close. XRNotify delivers these events with transaction details and state changes included.

Network state monitoring helps infrastructure providers track validator changes, fee updates, and amendment voting. These events feed into broader system health monitoring.

Ecosystem Connections

XRNotify generates network state data that flows to The Neutral Bridge for financial infrastructure research. When transaction patterns indicate potential issues, those anomaly signals feed into H.U.N.I.E.'s intelligence layer.

The Circuit Breaker component in H.U.N.I.E. Sentinel relies on XRNotify's real-time monitoring to detect unusual activity patterns and trigger protective measures when needed.

This integration approach means the webhook infrastructure serves dual purposes: individual developer needs and ecosystem-wide intelligence gathering.

Technical Implementation

The Next.js 14 frontend provides webhook management and event debugging tools. Developers configure endpoints, view delivery logs, and test webhook signatures through the dashboard.

XRPL.js handles all ledger interactions. The worker processes maintain redundant connections to prevent single points of failure. Event processing includes validation against XRPL transaction formats and automatic retries for network hiccups.

Rate limiting and delivery scheduling prevent webhook endpoints from getting overwhelmed during high-activity periods.

Solving Infrastructure Debt

Before XRNotify, XRPL developers built monitoring systems that worked until they didn't. Connection drops meant missed transactions. Failed webhook deliveries disappeared without trace. Debugging required diving through logs with limited visibility.

XRNotify consolidates this infrastructure layer. Developers configure their events and endpoints, then receive reliable delivery with full debugging support. The monitoring infrastructure becomes operational overhead someone else maintains.

Check out XRNotify

Building Guard-Clause: AI-Powered Contract Analysis Without the Legal Team

Jonomor — Wed, 08 Apr 2026 19:51:11 +0000

Contracts are everywhere in business, but analyzing them shouldn't require a law degree or a legal team on retainer. I built Guard-Clause to solve a fundamental problem: individual professionals and small businesses face the same complex contracts as large enterprises, but without the resources to properly analyze them.

Guard-Clause is an AI-powered contract analysis platform that reads any contract and returns clause-level risk findings with severity scoring, negotiation scripts, and replacement language. It's not a document viewer or keyword highlighter. It's a structured analysis engine that applies a defined methodology to unstructured legal text.

The Technical Problem

Most contract tools are built around document management or simple keyword matching. They miss the structural analysis that legal professionals perform when reviewing agreements. A clause isn't risky because it contains certain words—it's risky because of its relationship to other clauses, its enforceability, and its impact on business operations.

The challenge was building a system that could understand legal context, identify problematic patterns, and provide actionable guidance without requiring users to interpret legal jargon themselves.

Architecture Decisions

I built Guard-Clause on Next.js 15 with Supabase for data persistence and Stripe for payments. The core analysis engine runs on Anthropic's Claude API, chosen for its strong performance on complex text analysis tasks.

The privacy architecture was foundational, not an afterthought. All contract data flows through an ephemeral Redis cache with a 15-minute TTL. No contract content is permanently stored. Analysis results are delivered in real time, and the source document is automatically purged. This is privacy by default, not privacy as a feature toggle.

This approach required careful orchestration. The system had to process documents, extract clauses, analyze risk patterns, generate negotiation scripts, and deliver results—all within the ephemeral window. The Redis implementation handles this through structured job queues that track analysis state without persisting source material.

How It Works

Users upload a contract and Guard-Clause performs clause-level analysis across multiple dimensions. Each clause receives a severity classification: Critical, High, Medium, or Low risk. For problematic clauses, the system generates specific negotiation scripts and suggests replacement language.

The analysis engine doesn't just flag issues—it provides context. A liability cap clause might be flagged as high-risk not because liability caps are inherently bad, but because this particular cap is unusually low relative to the contract value, or because it excludes categories that should be covered.

Multi-persona analysis allows users to view contracts through different lenses: buyer, seller, contractor, or client. The same clause can present different risk profiles depending on your position in the transaction.

Ecosystem Integration

Guard-Clause operates within the Jonomor ecosystem, feeding legal pattern intelligence to H.U.N.I.E., the central memory engine. This creates compound value—each contract analysis contributes to institutional-grade legal intelligence that improves future analysis.

MyPropOps, another platform in the ecosystem, reads Guard-Clause patterns when reviewing lease clauses. A property manager analyzing a commercial lease benefits from patterns learned across thousands of previous contract reviews.

Technical Implementation

The analysis pipeline processes contracts through several stages: document parsing, clause extraction, risk assessment, and recommendation generation. Each stage operates independently, allowing for parallel processing where possible.

The severity scoring system uses weighted risk factors rather than binary classifications. A clause might score high on financial exposure but low on enforceability risk. The final severity rating reflects the compound risk profile, not just individual factors.

Addendum generation was particularly complex to implement. The system needs to understand which clauses can be modified through addenda versus those requiring direct contract amendment, then generate legally coherent language that addresses identified risks.

Why This Matters

Contract analysis shouldn't be a luxury service available only to large organizations. Small businesses negotiate software licenses, consulting agreements, and vendor contracts daily. Individual professionals sign employment agreements, consulting contracts, and partnership deals. They deserve the same quality of legal intelligence that Fortune 500 companies get from their legal teams.

Guard-Clause democratizes contract intelligence without compromising on privacy or analytical depth. It's contract analysis for everyone else.

Try it yourself: https://www.guard-clause.com

Building AI Visibility Infrastructure: Inside Jonomor's Architecture

Jonomor — Wed, 08 Apr 2026 19:49:56 +0000

I built Jonomor because the industry was solving the wrong problem. SEO professionals kept optimizing for rankings while AI answer engines like ChatGPT, Perplexity, and Gemini were pulling citations from knowledge graphs. The fundamental disconnect is structural — AI engines retrieve entities, not content volume.

The Technical Problem

When you ask ChatGPT about property management software or XRPL webhooks, it doesn't scan web pages like Google. It queries its knowledge graph for entities that match semantic patterns. Traditional SEO assumes crawlers parse content linearly. AI engines work differently — they map entity relationships and surface authoritative sources through graph traversal.

The gap creates a citation problem. Organizations with strong SEO metrics get ignored by AI answer engines because their entity architecture is weak. Meanwhile, domains with clear entity definitions and stable schema relationships consistently get cited, regardless of traditional ranking factors.

The AI Visibility Framework

I developed a six-stage, 50-point scoring methodology to measure what actually drives AI citations:

Entity Stability evaluates whether your domain maintains consistent identity markers across time. AI engines need stable reference points to build confidence in your authority.

Category Ownership measures semantic association between your entity and specific knowledge domains. The stronger your categorical binding, the more likely AI engines surface you for relevant queries.

Schema Graph analyzes your structured data implementation. Clean schema markup creates clear entity boundaries that AI engines can parse reliably.

Reference Surfaces tracks external validation signals. Citation patterns, backlink authority, and cross-domain entity mentions build cumulative trust.

Knowledge Index measures your content's integration into broader knowledge networks. AI engines prioritize sources that connect well to existing information architectures.

Continuous Signal Surfaces evaluates real-time entity activity. Fresh signals indicate living, authoritative sources rather than static reference material.

Architecture Decisions

Jonomor operates as a hub for nine production properties, each serving different markets while contributing to the overall entity graph. Guard-Clause handles AI contract analysis, XRNotify provides XRPL webhook infrastructure, MyPropOps manages property operations, The Neutral Bridge researches financial infrastructure, Evenfield powers AI homeschool education, and JNS Studios creates children's content.

The technical architecture centers on H.U.N.I.E., a shared intelligence layer that connects all properties. Every domain declares isPartOf Jonomor while Jonomor declares hasPart for each property. This creates clear entity hierarchies that AI engines can map consistently.

I built the automated AI Visibility Scorer to evaluate any public domain against the framework in real time. The tool runs on Next.js with TypeScript, using Anthropic's Claude API for semantic analysis and Railway for deployment infrastructure. Tailwind CSS keeps the interface clean and functional.

Why This Matters for Developers

Four of our domains score 48/50 Authority on the AI Visibility Framework. This isn't accidental — it's the result of deliberate entity architecture decisions. When you build with AI citation in mind, you create systems that both humans and AI engines can understand clearly.

The shift from content optimization to entity optimization changes how we structure applications. Database schemas need to map to knowledge graph patterns. API responses should include structured entity data. Even URL structures should reflect semantic hierarchies rather than arbitrary navigation patterns.

The Ecosystem Approach

Rather than building isolated products, I designed each property to strengthen the overall entity network. When Guard-Clause analyzes contracts, it generates signals that feed back into Jonomor's authority. When XRNotify handles webhooks, it creates technical credibility that supports our infrastructure positioning.

This connected approach means AI engines see Jonomor as a multi-faceted authority rather than a single-purpose domain. The breadth creates trust while the depth in each area maintains relevance.

The infrastructure is working. Our domains consistently get cited by major AI engines for queries in their respective categories. More importantly, the framework provides a replicable methodology for other organizations facing the same citation gap.

AI Visibility is becoming as critical as traditional SEO, but it requires different thinking and different tools. That's what Jonomor provides.

Learn more at https://www.jonomor.com.

Building Forensic Infrastructure Research: The Neutral Bridge

Jonomor — Mon, 06 Apr 2026 16:54:08 +0000

I built The Neutral Bridge because the conversation around Ripple and XRP has been hijacked by price speculation. While traders debate moon shots and crashes, the actual story — how global settlement infrastructure is being systematically re-engineered — gets buried under market noise.

The Neutral Bridge is forensic-grade infrastructure research. Not market commentary. Not investment advice. It examines how settlement systems work, why they're changing, and what that transformation means for global finance.

The Signal-to-Noise Problem

Financial media treats blockchain infrastructure like sports betting. Every announcement gets filtered through price impact speculation instead of technical analysis. This creates a fundamental problem: the people building the next generation of settlement systems can't find serious technical discourse about what they're building on top of.

When I started researching how the XRP Ledger actually processes cross-border payments, I found endless price predictions and almost no forensic analysis of the underlying settlement mechanics. The engineering story was invisible.

Architecture and Data Flow

The Neutral Bridge reads live XRPL network state data through the Jonomor ecosystem's shared intelligence layer. XRNotify monitors validator changes, fee trends, and ledger performance metrics. This data flows through H.U.N.I.E.'s shared memory architecture, where it gets processed and fed into The Neutral Bridge's analysis engine.

The technical stack is deliberately lightweight: Vite with React 18, hosted on GitHub Pages. I chose this over complex backend infrastructure because the heavy lifting happens in the data processing layer, not the presentation layer. The site pulls processed intelligence from the ecosystem rather than trying to be a standalone analysis platform.

The publication includes an automated market-adaptive blog that responds to significant network state changes. When validator consensus shifts or fee structures change, the system flags these events for deeper analysis. This isn't automated content generation — it's automated research prioritization.

Forensic vs. Speculative Analysis

The difference between forensic and speculative analysis is methodology. Speculative analysis starts with a price target and works backward to justify it. Forensic analysis starts with network behavior and works forward to understand what it means.

When analyzing cross-border payment flows, for example, I trace actual transaction paths through the XRPL network. I examine which market makers are providing liquidity, how pathfinding algorithms route payments, and where settlement actually occurs. This reveals how the infrastructure works in practice, not just how it works in theory.

The publication achieved #1 New Release in Financial Engineering on Amazon because this kind of forensic approach fills a gap in financial literature. Most blockchain books are either beginner tutorials or investment guides. Very few examine settlement infrastructure from an engineering perspective.

Ecosystem Integration

The Neutral Bridge doesn't operate in isolation. It's part of a connected intelligence system where network monitoring (XRNotify), data processing (H.U.N.I.E.), and research publication work together. When the analysis identifies regulatory patterns or compliance implications, those findings feed back into the intelligence layer where they inform monitoring priorities.

This creates a feedback loop between observation and analysis. The monitoring system becomes more sophisticated as the research identifies what matters. The research becomes more targeted as the monitoring system identifies what's changing.

Retail and Institutional Editions

The publication comes in two formats. The retail edition focuses on accessible explanations of settlement infrastructure transformation. The institutional edition includes additional technical appendices, regulatory analysis, and network topology data that compliance teams and infrastructure architects need.

Both editions avoid price speculation entirely. The value is in understanding how settlement systems work, not predicting what tokens will do.

This is infrastructure research for builders who need to understand what they're building on top of, regulators who need to understand what they're regulating, and anyone who wants to understand how global settlement is being re-engineered beneath the market noise.

Visit The Neutral Bridge at https://www.theneutralbridge.com.

Building Compliance-First Property Management Software

Jonomor — Mon, 06 Apr 2026 16:49:55 +0000

Property management software treats compliance as an afterthought. You manage properties, track maintenance, collect rent — then scramble to generate compliance reports when an inspection happens. I built MyPropOps because audit trails shouldn't be something you construct after an inspection fails. They should be a byproduct of doing the work.

The Compliance Problem

Most property management tools follow the same pattern: build features for day-to-day operations, then bolt on compliance reporting. This creates gaps. A maintenance request gets logged, but the timestamps are inconsistent. Tenant communications happen through multiple channels with no unified record. When HUD comes knocking, property managers spend days reconstructing what actually happened.

The fundamental issue is architectural. If compliance isn't built into the data model from the beginning, you're always playing catch-up.

Architecture Decisions

MyPropOps inverts this approach. Every operation — maintenance requests, tenant interactions, document exchanges — generates timestamped, immutable records by design. The compliance architecture isn't layered on top; it's the foundation.

The tech stack reflects this priority. FastAPI handles the backend with MongoDB for document storage, giving us flexible schema design for different property types while maintaining strict audit requirements. Every API endpoint logs operations with full context. React provides the frontend with three distinct portals: property managers see everything, tenants see their unit and requests, contractors see assigned work orders.

I chose MongoDB specifically for its document model. Property compliance requirements vary by jurisdiction, property type, and program participation. Rather than force complex relational schemas, each property stores its compliance profile as a document. Inspection templates adapt to HUD requirements, local housing codes, or custom standards without schema migrations.

The Inspection System

HUD-ready inspection templates were the starting point. I reverse-engineered actual HUD inspection forms and built the data structures to match. When an inspector enters findings, the output formats match exactly what housing authorities expect. No translation layer, no reformatting.

But the real value comes from connecting inspections to daily operations. If a tenant reports a heating issue in January and the same unit fails heating inspection in March, that timeline is preserved. Property managers can demonstrate response patterns, not just individual incidents.

Ecosystem Integration

MyPropOps doesn't exist in isolation. It reads lease clause risk intelligence from Guard-Clause, our lease analysis tool. If Guard-Clause identifies problematic language around maintenance responsibilities, MyPropOps flags related work orders for extra documentation.

The operational data flows to H.U.N.I.E., our predictive analytics engine. Maintenance patterns, tenant behavior, vacancy rates — all feed into models that predict which units need attention before problems escalate. The compliance trail provides the training data for these predictions.

Mobile and Contractor Experience

Capacitor handles mobile deployment because property management happens in the field. Maintenance technicians update work orders from basements and rooftops. The offline capabilities ensure records aren't lost when cell service drops.

Contractors get a focused portal showing only their assigned work. They upload photos, mark completion, note parts used. Every action feeds the audit trail without exposing sensitive tenant information or financial data.

Implementation Reality

The compliance-first approach requires discipline. Every feature decision gets evaluated against audit requirements. User experience matters, but not at the expense of record integrity. This constraint actually improves design — when you can't hide complexity, you're forced to make operations genuinely simpler.

Property managers using MyPropOps report that compliance reporting becomes a non-event. The data already exists in the required format because that's how it was captured originally.

Building compliance into the foundation rather than bolting it on afterward changes everything about how property management software works. The audit trail isn't overhead — it's the proof that you're doing the job right.

MyPropOps

Building Enterprise-Grade XRPL Webhook Infrastructure

Jonomor — Mon, 06 Apr 2026 16:48:24 +0000

When I started building applications on the XRP Ledger, I kept running into the same problem. Every XRPL developer was building their own event listener from scratch — monitoring wallet activity, watching for specific transactions, tracking network state changes. The implementations were consistently brittle: no retry logic, no dead-letter queues, minimal monitoring. Developers would write a basic WebSocket listener, maybe add some error handling, and call it done.

This approach works until it doesn't. Network hiccups cause missed events. Server restarts lose connection state. Failed webhook deliveries disappear into the void. You end up with gaps in your data and no reliable way to recover.

XRNotify solves this by providing enterprise-grade webhook infrastructure specifically for XRPL developers. Instead of building and maintaining your own listener infrastructure, you configure XRNotify to monitor the events you care about and deliver them to your endpoints with proper reliability guarantees.

The Technical Problem

The XRPL provides real-time data through WebSocket connections, but turning that into reliable webhook delivery requires solving several infrastructure challenges:

Connection Management: Maintaining persistent WebSocket connections to XRPL nodes, handling reconnection logic, managing subscription state across network failures.

Event Processing: Filtering and transforming raw XRPL data into structured webhook payloads. Supporting different event types — wallet activity, transaction confirmations, network state changes, validator updates.

Delivery Reliability: Implementing exponential backoff retry logic, dead-letter queues for permanently failed deliveries, signature verification for payload authenticity.

Scale and Performance: Handling thousands of concurrent webhook subscriptions, processing high-volume transaction streams, maintaining sub-second delivery latencies.

Most developers don't want to solve these problems. They want to focus on their application logic, not infrastructure.

Architecture Decisions

XRNotify is built on Next.js 14 with PostgreSQL for persistence and Redis for caching and job queuing. The core event processing runs on Node.js workers that maintain persistent connections to multiple XRPL nodes.

The worker architecture separates concerns cleanly. Connection managers handle WebSocket lifecycle and reconnection logic. Event processors transform raw XRPL data into structured payloads. Delivery workers handle webhook dispatch with retry logic and failure tracking.

We support 22+ event types across 7 categories: wallet activity, transaction events, network state, validator updates, amendment tracking, order book changes, and system health metrics. Each event type has its own processing pipeline with appropriate filtering and transformation logic.

Every webhook payload includes HMAC-SHA256 signature verification. Delivery failures trigger exponential backoff retry with jitter to prevent thundering herd problems. After exhausting retries, failed deliveries move to a dead-letter queue where they're available for manual inspection and redelivery.

Ecosystem Integration

XRNotify isn't just standalone infrastructure — it's a data source for the broader Jonomor ecosystem. Network state data flows to The Neutral Bridge for financial infrastructure research. Transaction anomaly patterns feed into H.U.N.I.E.'s intelligence layer. The real-time event stream powers circuit breaker functionality in H.U.N.I.E. Sentinel.

This integration creates a feedback loop. As XRNotify processes more XRPL events, it improves the intelligence available to other Jonomor products. As those products identify new patterns, they can configure additional monitoring through XRNotify.

Implementation Details

The webhook delivery system uses a multi-tier retry strategy: immediate retry for transient failures, exponential backoff for persistent failures, and dead-letter storage for permanent failures. Redis job queues handle the retry scheduling with proper priority and rate limiting.

For high-volume subscriptions, we batch webhook deliveries when possible while maintaining event ordering guarantees. The system tracks delivery metrics per endpoint and automatically adjusts retry parameters based on observed reliability patterns.

Security is built-in, not bolted-on. Every payload is signed with HMAC-SHA256 using per-webhook secrets. We support IP allowlisting and can restrict webhook deliveries to specific network ranges.

XRNotify provides the infrastructure layer the XRPL ecosystem was missing. Instead of building unreliable listeners, developers can focus on their applications while trusting that critical events will be delivered reliably.

Check it out at https://www.xrnotify.io.

Building AI Visibility Infrastructure: The Jonomor Framework

Jonomor — Mon, 06 Apr 2026 16:43:05 +0000

When ChatGPT cites sources in its responses, where does it pull that information from? When Perplexity generates answers with references, what determines which organizations get mentioned? The answer isn't traditional SEO rankings—it's entity architecture in knowledge graphs.

I built Jonomor because the industry was missing this fundamental shift. SEO professionals were still optimizing for search rankings while AI answer engines were retrieving structured data from entirely different systems. The gap between traditional SEO and AI citation isn't tactical—it's architectural.

The Technical Problem

AI answer engines like ChatGPT, Perplexity, and Gemini don't crawl web pages the way search engines do. They access pre-trained knowledge graphs where information exists as structured entities with defined relationships. Your organization either exists as a recognizable entity in these systems or it doesn't. Content volume alone won't fix architectural invisibility.

Traditional SEO metrics—keyword rankings, backlink counts, domain authority—don't predict AI citation. I've observed organizations with strong SEO performance getting zero AI mentions while lesser-known entities with proper schema markup and entity relationships consistently appear in AI responses.

The AI Visibility Framework

I developed a six-stage, 50-point scoring methodology that measures actual AI citation factors:

Entity Stability evaluates organizational identity consistency across knowledge graphs. Category Ownership measures topical authority within specific domains. Schema Graph assesses structured data implementation and entity relationships. Reference Surfaces tracks citation-worthy content formats. Knowledge Index measures presence in training datasets. Continuous Signal Surfaces evaluates ongoing entity reinforcement.

The automated AI Visibility Scorer at jonomor.com/tools/ai-visibility-scorer runs this evaluation against any public domain in real time. It's built with Next.js and TypeScript, using the Anthropic Claude API for analysis and deployed on Railway.

Architecture Decisions

Rather than building a standalone consultancy, I architected Jonomor as the hub of a nine-property ecosystem. Each property serves a specific market while contributing entity data to a shared intelligence layer called H.U.N.I.E.

The properties include Guard-Clause for AI contract analysis, XRNotify for XRPL webhook infrastructure, MyPropOps for property management, The Neutral Bridge for financial infrastructure research, Evenfield for AI-powered homeschool education, AI Presence for continuous signal surfaces, and JNS Studios for children's content.

Every property declares isPartOf Jonomor in its structured data. Jonomor declares hasPart for all nine properties. This creates a documented entity graph that AI systems can parse and understand. Four domains currently score 48/50 Authority on the AI Visibility Framework—validation that the architecture works.

The H.U.N.I.E. System

H.U.N.I.E. serves as the central memory infrastructure connecting all properties. It aggregates intelligence across domains, enabling cross-property insights and coordinated entity reinforcement. When one property generates relevant data, H.U.N.I.E. makes it available to others in the network.

This isn't just data sharing—it's structured entity relationship building. AI systems recognize these connections because they're explicitly declared through proper schema markup and consistent entity references.

Implementation Strategy

The technical approach prioritizes entity architecture over content volume. Every page implements comprehensive schema.org markup. Entity relationships are explicitly declared. Content formats align with AI citation preferences—structured data, clear attributions, authoritative sources.

The AI Visibility Scorer provides continuous measurement. Instead of guessing whether changes improve AI citation, organizations can measure their actual visibility score against the 50-point framework.

What This Means for Developers

If you're building products that need AI visibility, traditional SEO won't get you there. You need entity architecture—structured data that AI systems can parse, entity relationships they can follow, and content formats they prefer to cite.

The shift from search rankings to knowledge graph entities changes how we build for discoverability. It's not about gaming algorithms—it's about becoming a recognizable entity in the knowledge systems that AI uses to generate responses.

Visit https://www.jonomor.com to explore the AI Visibility Framework and run the automated scorer against your domain.

Guard-Clause: AI Contract Analysis Without the Legal Team

Jonomor — Mon, 06 Apr 2026 16:42:06 +0000

I built Guard-Clause because contract review shouldn't require a legal department. Small businesses and individual professionals face the same complex agreements as Fortune 500 companies, but they lack the resources to analyze them properly. The result is signing documents with hidden risks or paying thousands for basic legal review.

Guard-Clause is an AI-powered contract analysis platform that reads any contract and returns clause-level risk findings with severity scoring, negotiation scripts, and replacement language. It's not a document viewer that highlights keywords. It's a structured analysis engine that applies a defined methodology to unstructured legal text.

The Technical Problem

Contract analysis requires understanding context, implication, and risk across interconnected clauses. A termination clause might seem reasonable in isolation, but combined with specific payment terms and liability limitations, it could create asymmetric risk. Traditional document tools treat contracts as collections of isolated paragraphs. Legal professionals understand the relationships between clauses, but that knowledge doesn't scale.

The challenge was building a system that could map these relationships automatically, score risk at the clause level, and generate actionable recommendations without storing sensitive contract data.

Architecture Decisions

Privacy drives every technical decision in Guard-Clause. All contract data flows through an ephemeral Redis cache with a 15-minute TTL. No contract content touches permanent storage. Analysis results are delivered in real time, and the source document is purged automatically.

This isn't privacy as a feature toggle—it's privacy by default. I've seen too many legal tech platforms that store everything first and add privacy controls later. Guard-Clause processes documents in memory, extracts patterns and risk signals, then discards the source material. The only artifacts that persist are anonymized pattern data that feeds into the broader Jonomor ecosystem.

The analysis engine runs on Next.js 15 with Supabase handling user management and analysis history (not contract content). Anthropic's Claude API powers the contract interpretation, chosen for its strong reasoning capabilities across complex legal text. Stripe handles payments, and Redis provides the ephemeral processing layer.

How It Works

Upload a contract, and Guard-Clause identifies individual clauses, classifies them by type, and scores risk severity from Critical to Low. Each finding includes specific negotiation scripts and replacement language suggestions. The system can analyze contracts from multiple personas—buyer, seller, vendor, client—since the same clause carries different risks depending on your position.

For complex agreements, Guard-Clause generates addendums with specific language to address identified risks. This turns the analysis into actionable contract amendments.

Ecosystem Integration

Guard-Clause feeds legal pattern intelligence to H.U.N.I.E., the central memory engine in the Jonomor ecosystem. This isn't just data storage—it's compound legal intelligence. Each contract analysis contributes to a growing understanding of legal patterns, clause effectiveness, and risk relationships.

MyPropOps, another tool in the ecosystem, reads these patterns when reviewing lease clauses. The legal intelligence accumulated in Guard-Clause improves decision-making across the entire platform.

The Builder's Perspective

Building Guard-Clause meant solving for both technical complexity and user simplicity. The underlying analysis engine handles intricate legal relationships, but the interface delivers clear, actionable results. A small business owner can upload a vendor agreement and receive specific talking points for their next negotiation call.

The privacy architecture added complexity but was non-negotiable. Legal documents contain the most sensitive business information. Building trust requires demonstrating that privacy isn't an afterthought—it's the foundation.

Contract analysis shouldn't be a luxury service. Guard-Clause democratizes legal intelligence, turning complex agreements into structured risk assessments that any business professional can understand and act on.

Try Guard-Clause at https://www.guard-clause.com.

Building AI Visibility Infrastructure: The Technical Architecture Behind Jonomor

Jonomor — Mon, 06 Apr 2026 02:45:06 +0000

Traditional SEO is failing in the age of AI answer engines. While SEO professionals optimize for search rankings, AI systems like ChatGPT, Perplexity, and Gemini retrieve information through entity relationships and knowledge graphs. The gap is structural, not tactical.

I built Jonomor to solve this problem at the infrastructure level.

The Technical Problem

AI answer engines don't crawl pages looking for keywords. They query knowledge graphs for entities with established relationships and verified attributes. When someone asks Claude about property management software, it doesn't scan blog posts—it looks for entities that declare themselves as property management platforms with supporting schema and reference surfaces.

The existing optimization frameworks focus on content volume and backlink quantity. But AI systems prioritize entity stability, categorical authority, and structured data relationships. Organizations that understand this distinction get cited. Those that don't become invisible to AI systems.

Architecture Decisions

Jonomor operates as a hub with nine production properties connected through a shared intelligence layer called H.U.N.I.E. Each property serves a specific market while contributing to the overall entity graph.

The architecture follows three core principles:

Entity-First Design: Every property declares structured relationships using Schema.org markup. Jonomor declares hasPart for all nine properties. Each property declares isPartOf Jonomor. This creates a verifiable organizational hierarchy that AI systems can traverse.

Distributed Authority: Rather than building one large platform, I created nine focused properties across different categories—AI contract analysis (Guard-Clause), property management (MyPropOps), financial infrastructure research (The Neutral Bridge), and others. Each property establishes category ownership in its domain while feeding intelligence back to the central system.

Continuous Signal Surfaces: Traditional websites are static. AI systems need continuous signals to verify entity status. The H.U.N.I.E. memory infrastructure tracks state changes across all properties, updating the central knowledge graph in real time.

The AI Visibility Framework

The framework evaluates AI citation potential across six stages with 50 total points:

Entity Stability (10 points): Consistent organizational identity across web properties
Category Ownership (10 points): Authoritative content that defines industry categories
Schema Graph (10 points): Structured data relationships that AI systems can parse
Reference Surfaces (5 points): Third-party citations and mentions
Knowledge Index (10 points): Presence in authoritative knowledge bases
Continuous Signal Surfaces (5 points): Real-time updates and activity signals

Four of my properties score 48/50 Authority on this framework. The AI Visibility Scorer at jonomor.com/tools/ai-visibility-scorer automates this evaluation for any public domain.

Technical Implementation

The tech stack prioritizes speed and AI integration:

Next.js/TypeScript: Server-side rendering for optimal crawlability
Tailwind CSS: Consistent design system across all properties
Anthropic Claude API: Natural language processing for content analysis
Railway: Deployment infrastructure that scales with usage

The scorer runs entirely client-side, analyzing domains in real time without storing user data. It queries public APIs for schema validation, knowledge base presence, and entity relationship verification.

Ecosystem Integration

H.U.N.I.E. functions as the central memory system. When Guard-Clause processes a contract, that intelligence flows back to Jonomor's strategy agent. When MyPropOps identifies a property management trend, it updates the shared knowledge graph. This creates compound intelligence that improves citation potential across all properties.

The ecosystem approach solves a fundamental problem with AI visibility—isolated websites struggle to establish authority. But interconnected properties with shared intelligence create entity graphs that AI systems can confidently cite.

Building for AI Systems

Every technical decision considers how AI systems will interpret and utilize the information. Clean schema markup, consistent entity declarations, and verifiable relationships matter more than traditional SEO signals.

This isn't about gaming AI systems—it's about building infrastructure that aligns with how these systems actually retrieve and verify information.

Jonomor defines AI Visibility as a technical discipline. The frameworks, tools, and entity architecture determine whether organizations exist in the AI-powered information ecosystem.

https://www.jonomor.com