Jay Thornton

I’ve spent the last year trying to figure out why automation still feels broken — even when it’s working exactly as designed.

Triggers fire. Sequences run. Messages go out on time. On paper, everything is functioning. But in practice, automated communication often feels disconnected, mistimed, or oddly unaware of what’s actually happening.

That gap isn’t caused by a lack of tools. It’s caused by a lack of context.

Most automation systems are built around rules, not understanding. Something happens, so something gets sent. There’s no awareness of why the event occurred, what came before it, or whether the message still makes sense in the larger story.
That distinction matters more than most teams realize.

Why Rules Alone Don’t Scale Relationships

Rules are binary. Either a condition is met or it isn’t. But real business interactions don’t work that way.
A lead fills out a form after a sales call, not before it. A customer opens an email while already deep in a buying process. A follow-up arrives after the decision has been made — just not in your system.
When automation ignores those realities, communication becomes noise. It may still get opened. It may still technically “perform.” But it stops feeling intentional. At scale, that’s costly. Not just in unsubscribe rates, but in trust.

Context Changes Everything

Context-aware automation behaves differently. It doesn’t ask, “Did this event happen?” It asks, “What does this event mean?” That shift requires seeing more than one data point at a time. It means understanding engagement history, sales activity, timing, and intent — and using that broader picture to decide whether a message should be sent at all.

AI doesn’t fix this by default. Most AI in email tools is just a faster way to send the wrong message. The problem was never speed. It was awareness.

Fragmented Systems Can’t See the Whole Story

I’ve watched this firsthand. CRM data in one tab. Email platform in another. Sales notes in a third. Each system confident it’s doing its job, none of them aware of the others.

When systems can’t see the whole story, automation can’t act intelligently.

Bringing those signals together — behavior, engagement, timing, and outcomes — is the difference between automation that executes and automation that understands.
What I’m Building Toward

This is the gap I’ve been thinking about for the last year. Not smarter emails. Not cleverer sequences. Better decisions.

At LeadMachine.fyi, I’m designing automation around shared context — not just email triggers. The goal isn’t to send more messages. It’s to surface the right action at the right moment, based on what’s actually happening across a business, not just inside an inbox.
When automation understands context, it stops feeling automated. It starts feeling considered.

That’s the direction I’m pushing — both in how I think about systems and in what I’m building.
Because communication doesn’t break when tools fail. It breaks when understanding is missing.

~jt

Have questions or comments? Get in touch! I can even schedule a demo!

I’ve spent most of my career building SaaS products around a simple question:

Does this actually make someone’s work clearer and easier?

Over time, I’ve become increasingly skeptical of software that promises transformation but delivers more complexity. This is especially true in the CRM space. Most CRMs today are very good at collecting data and very bad at helping people understand what to do with it.

They track activity, store contacts, and generate reports. But when you ask the questions that matter in the moment, the answers are usually buried.

That gap isn’t a data problem. It’s a clarity problem.

That gap is why I built LeadMachine.

LeadMachine is an AI-enriched CRM designed around decision-making, not record keeping. The goal isn’t to add more dashboards or automate everything in sight. It’s to reduce noise, surface signal, and help teams understand what actually matters right now.

You can see the product and its thinking at https://leadmachine.fyi.

Functional AI, Applied Where It Matters

I’ve written before about my skepticism toward AI for AI’s sake. The same rule applies here as it does everywhere else I build software:

If AI doesn’t make something clearer, faster, or genuinely more useful, it doesn’t belong in the product.

LeadMachine uses AI in a functional way. It analyzes patterns across leads, companies, and user activity and turns that information into summaries, priorities, and context. Instead of forcing users to interpret raw data, the system helps interpret it for them.

This isn’t about replacing human judgment. It’s about supporting it.

When applied thoughtfully, AI becomes a compression tool. It shortens the distance between data and understanding. That’s the role it plays inside LeadMachine.

A CRM That Respects Attention

One of the things that frustrates me most about modern SaaS is how little respect it shows for user attention. More features, more alerts, more tabs, more noise.

LeadMachine is intentionally opinionated in the opposite direction.

It focuses on:

• What’s changing
• What’s stalled
• What needs attention today
• What activity is actually moving the needle

Not everything needs to be visible all the time. Not every data point needs equal weight. Good software makes tradeoffs on behalf of the user.

That philosophy runs through every part of LeadMachine.

Why This Matters Now

CRMs were built for a different era. An era where manual follow-up was expected and insight came from end-of-month reports. That world doesn’t exist anymore.

AI changes the expectations. Teams no longer need more data. They need better understanding.

LeadMachine is my attempt to build a CRM that reflects that shift. A system that acts less like a database and more like a thinking partner.

If you’re interested in where CRMs are headed, how AI can be applied responsibly, or what it looks like to build modern SaaS with clarity as a first principle, you can explore more at https://leadmachine.fyi.

I’ll continue writing here about the ideas, decisions, and lessons behind the product. Not as announcements, but as an ongoing exploration of how software should work when it’s built with intent.

I’ve been building SaaS platforms for over a decade now, and for the past two years, I’ve been focused on how AI can be thoughtfully integrated—not as a gimmick, but as a functional layer that improves the product experience. Every platform I’ve worked on—whether CRM, scheduling, or internal tools—has pushed me to ask better questions: What’s essential? What’s scalable? What genuinely improves how people work?

It’s easy to get distracted in this space. New frameworks. Shiny plugins. AI hype. But under all that,

Good software is still just a series of thoughtful decisions—stacked carefully and built to last.

That’s where I try to stay grounded.

---

Let’s Talk About AI (But Actually Talk About It)

AI is everywhere now—and too often, it’s thrown at problems it doesn’t actually solve. I’ve seen “AI-powered” features that are basically autocomplete in a trench coat. So I set a rule for myself:

If AI doesn’t make something faster, clearer, or less manual—I don’t ship it.

In the platforms I’ve built, AI shows up only where it earns its place:

• Smarter lead management and routing based on real usage patterns
• Context-aware interfaces that adapt by role, behavior, and history
• AI-generated summaries and insights that reduce busywork
• Natural language prompts to surface actions faster

When done right, AI disappears into the workflow. It’s invisible, seamless, and useful. If it feels like an add-on, it probably is.

Modular Everything (Because Flexibility Is Freedom)

One of the biggest unlocks this year has been leaning into modular development—especially when you’re iterating fast or supporting multiple use cases.

I’ve rebuilt core parts of these platforms using modular PHP and JS components so that every element can be reused, tested, and evolved independently. Scoped scripts. Smart defaults. Minimal bloat. Not glamorous—but it’s what keeps the product moving.

• A dynamic modal system used across profiles, leads, users, and settings
• Reusable search and filter logic that adapts to any dataset
• API-first routes that simplify mobile extensions and third-party tools
• Granular role logic that does more than just restrict access

The mindset is simple: Can this scale without becoming brittle? If not, I refactor until it can.

Testing Early, Testing Often

Here’s the part most indie devs gloss over: testing.

I’ve been leaning into lightweight automated testing and soft CI—not because I’m chasing “enterprise best practices,” but because I’ve lived the pain of broken updates. I’d rather catch issues with a validation layer than rely on luck and late-night QA scrambles.

• Backend tests to validate logic, input, and permissions
• Frontend sanity checks for key flows
• Change logging that helps me trace “what changed and why”

Testing doesn’t slow you down—it frees you up. It lets you move fast without fear. That’s a lesson I wish I’d absorbed earlier in my career.

I’m still obsessed with building software that respects people’s time. That removes friction. That feels intuitive from day one—and quietly improves behind the scenes.

If you’re building with the same mindset—modular, human-first, and focused on solving real problems—I’d love to connect and swap notes.

You can find me across social platforms at @jaythornton000, or reach out directly via my contact page.

There’s still so much to build. But it’s better when you build it right.

---

Want to Learn More?

Ask a question.