When growth is slow, leads are inconsistent, the tech is clumsy, or the offer is not converting, the problem is rarely effort. The problem is usually positioning, speed, clarity, automation, and execution. I help founders, operators, investors, and small business owners build practical systems that save time, make money, protect margin, and move projects from idea to launch.
When the website looks decent but still does not sell, trust leaks out fast. I build pages and systems that clarify the offer, remove friction, and turn attention into inquiries so the business can move faster.
Free Consultation
If the message is vague, the market hesitates. I tighten positioning, sharpen the promise, and build direct-response marketing assets that help you get attention, create demand, and make more money.
Free Consultation
If people cannot find you, they cannot buy from you. I improve SEO structure, metadata, headings, internal clarity, and keyword targeting so the site has a better chance to rank, attract clicks, and save wasted ad spend.
Free Consultation
Manual work compounds into delay, payroll drag, and avoidable mistakes. I build custom software, admin tools, dashboards, and workflow systems that save time, reduce friction, and give you more control over operations.
Free Consultation
When the mobile experience is clumsy, leads disappear before they ever talk to you. I build responsive, mobile-first experiences and app-style workflows designed to make action easy on the device people use most.
Free Consultation
Sometimes the fastest way to save time and money is to identify the real bottleneck first. Use the free consultation to map the problem, define the solution, and get a clearer path to speed, revenue, and execution.
Free Consultation
Tell me what is broken, slow, expensive, or stuck — and what outcome you want instead.
Notes on what I'm building.
A man is defined not by the chaos he avoids, but by the order he builds in spite of it. Over fifteen years of shipping software, closing deals, and constructing systems that outlast the people who made them — that is the work. That is the record.
Foundational systems thinking, algorithms, and application development. The credential was the starting point; the real education happened in production systems, under real pressure, serving real clients.
Former teacher and long-time mentor — (724) 826-8837
(412) 657-0010
(330) 979-2466
(412) 600-3099
Ideas without execution are fantasies. Every project below represents a problem taken seriously, constraints respected, and a result that stood in front of real users under real conditions.
Standalone VSCode extension that turns the editor into a multi-LLM chat panel — direct API or browser bridge, no provider lock-in. 20 chat / inference / video-gen bridges ship in the box: Claude, ChatGPT, Gemini, Grok, Copilot, DeepSeek, Ollama (enabled by default), plus Perplexity, Mistral, Pi, HuggingChat, Veo, Runway, Luma, Kling, fal.ai, Replicate, OpenRouter, Groq, Pika (off by default).
Pluggable .bridge XML extension system — drop a single
XML file in extensions/ to register a new provider. Features
multi-account management, TTS/STT, attach-to-file, slash commands
(/switch, /compact, /attach, …),
14 visual skins, 50+ language translations, and a built-in Tamagotchi pet.
Download VSIX → Source on GitHub
Private business acquisition investment firm targeting established Main Street companies at 2–4× EBITDA. Full investor-facing website built on a custom PHP CMS with nginx, SimpleCrud, elFinder, and blueimp Gallery. 81-page investor report pipeline with server-side charts via matplotlib and Plotly. acquisitioninvest.com
Consulting practice focused on helping business owners sell at full price rather than accepting lowball acquisition offers. Strategy, positioning, and deal preparation for Main Street business owners. fullpriceexit.com — (724) 431-5207
Educational resource covering the science, logistics, and practical considerations of cryonic preservation. Built to cut through the noise and give serious people serious information. practicalcryonics.com
Single-handedly built and maintained a full-featured SaaS platform for 300+ funeral home clients over five years. Custom ecommerce tied to Teleflora’s XML API, a vendor marketplace, auction system, and a templating engine designed for a non-developer. Physically built and colocated the production server. Acquired and sold, 2013.
Designed and built a complete ecommerce storefront for an educational supplies retailer using CodeIgniter MVC. Clean architecture built for maintainability.
Custom website for a Pittsburgh-based hauling business. Dark construction-themed design with local SEO optimization and a service presentation built for lead generation.
When the website looks decent but still does not sell, trust leaks out fast. I build pages and systems that clarify the offer, remove friction, and turn attention into inquiries so the business can move faster.
Free Consultation
If the message is vague, the market hesitates. I tighten positioning, sharpen the promise, and build direct-response marketing assets that help you get attention, create demand, and make more money.
Free Consultation
If people cannot find you, they cannot buy from you. I improve SEO structure, metadata, headings, internal clarity, and keyword targeting so the site has a better chance to rank, attract clicks, and save wasted ad spend.
Free Consultation
Manual work compounds into delay, payroll drag, and avoidable mistakes. I build custom software, admin tools, dashboards, and workflow systems that save time, reduce friction, and give you more control over operations.
Free Consultation
When the mobile experience is clumsy, leads disappear before they ever talk to you. I build responsive, mobile-first experiences and app-style workflows designed to make action easy on the device people use most.
Free Consultation
Sometimes the fastest way to save time and money is to identify the real bottleneck first. Use the free consultation to map the problem, define the solution, and get a clearer path to speed, revenue, and execution.
Free ConsultationWhen the website, offer, workflow, or follow-up system is weak, growth gets expensive. I help business owners tighten the message, improve the website, remove technical friction, and build practical systems that create a faster path from attention to action.
Built with the tools and models I use to move work from idea to shipped result.
When the website looks decent but still does not sell, trust leaks out fast. I build pages and systems that clarify the offer, remove friction, and turn attention into inquiries so the business can move faster.
Free Consultation
If the message is vague, the market hesitates. I tighten positioning, sharpen the promise, and build direct-response marketing assets that help you get attention, create demand, and make more money.
Free Consultation
If people cannot find you, they cannot buy from you. I improve SEO structure, metadata, headings, internal clarity, and keyword targeting so the site has a better chance to rank, attract clicks, and save wasted ad spend.
Free Consultation
Manual work compounds into delay, payroll drag, and avoidable mistakes. I build custom software, admin tools, dashboards, and workflow systems that save time, reduce friction, and give you more control over operations.
Free Consultation
When the mobile experience is clumsy, leads disappear before they ever talk to you. I build responsive, mobile-first experiences and app-style workflows designed to make action easy on the device people use most.
Free Consultation
Sometimes the fastest way to save time and money is to identify the real bottleneck first. Use the free consultation to map the problem, define the solution, and get a clearer path to speed, revenue, and execution.
Free ConsultationFlatLine supervises any Python script, watches heartbeats, detects freezes, opens an interactive crash console, and captures a stack trace plus variable dump the moment something goes wrong.
It supports both relay-backed heartbeat mode and a database-free poll mode, writes out stack_trace.log, variables.log, and error.log, and exposes a local socket REPL on localhost:5050 for live inspection.
The bundled demo app uses a white monospaced editor on the left and a full-height black/green output console on the right. It is designed to be edited live so you can trigger exceptions and test supervision behavior quickly.
When a crash, freeze, or manual pause occurs, FlatLine opens an interactive debug console with stack dump, variable dump, graceful close, terminate, kill, refresh, restart, shell commands, connection inspection, and monitoring controls.
FlatLine launches your Python app as a subprocess and stays outside the target process so the debugger remains useful even when the child becomes unstable.
It can detect freezes through relay-backed heartbeat events or through a non-blocking poll mode when you do not want MariaDB in the loop.
On failure it captures a stack trace and variable dump, then writes them to disk alongside a unified error log for later review.
The built-in console exposes stack, vars, close, terminate, kill, refresh, restart, shell commands, connection inspection, and network monitoring.
FlatLine opens a socket REPL on localhost:5050, which means you can inspect and interact without waiting for a crash first.
The package ships with a demo Qt app, an example launcher, HTML help, config file, and a lightweight remote client for adding beat() calls to your own app.
FlatLine runs in supervisor mode by default. The package README documents quick-start usage like python flatline.py app.py, alternate config support, and pass-through arguments for the child application.
python flatline.py app.pypython flatline.py --config myapp.inipython flatline.py --app script.pync localhost 5050PySide6 for the demo app and pymysql for MariaDB support
The package includes an example.py launcher that resolves a target app, forwards pass-through arguments, starts the debugger, prints relay details, and shuts down cleanly on Ctrl+C.
#!/usr/bin/env python3
"""
example.py — Flatline Usage Example
======================================
Demonstrates how to launch app.py under Flatline supervision.
Any arguments not consumed by this script are passed through to app.py.
Usage:
python example.py Launch app.py with Flatline
python example.py --help Show help
python example.py --version Show version
python example.py --app myapp.py Supervise a different script
python example.py -a --port 8080 Pass --port 8080 to the target app
Authors : Trent Tompkins <trenttompkins@gmail.com>
GPT-5.4 Plus Thinking
Claude Sonnet 4.6 (Anthropic)
Version : 1.0b | MIT License | https://github.com/tibberous/Flatline
"""
import sys
import os
import signal
from pathlib import Path
HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(HERE))
# ── Quick CLI ─────────────────────────────────────────────────────────────
_argv = sys.argv[1:]
_low = [a.strip().lower() for a in _argv]
if any(x in _low for x in ('--help', '-h', '/?', '/help', 'man', '--man')):
print(__doc__)
print("Full documentation: python flatline.py --help")
print(f"Project: https://github.com/tibberous/Flatline")
sys.exit(0)
if any(x in _low for x in ('--version', '--ver', '-v', '/v')):
from flatline import VERSION, BUILD_DATE, PROJECT
print(f'Flatline Example v{VERSION} ({BUILD_DATE})')
print(PROJECT)
sys.exit(0)
if any(x in _low for x in ('--license',)):
from flatline import MIT_LICENSE
print(MIT_LICENSE)
sys.exit(0)
# ── Resolve target app ────────────────────────────────────────────────────
target = HERE / 'app.py'
app_args = []
i = 0
while i < len(_argv):
arg = _argv[i]
low = arg.lower()
if low in ('--app', '-app') and i + 1 < len(_argv):
target = Path(_argv[i + 1]); i += 2; continue
if low in ('-a', '--args', '/args') and i + 1 < len(_argv):
app_args = _argv[i + 1:]; break
if not arg.startswith('-') and arg.endswith('.py'):
target = Path(arg)
elif arg.startswith('-') and low not in ('--app',):
app_args.append(arg)
i += 1
if not target.exists():
print(f"[example] Target not found: {target}", file=sys.stderr)
print(f"[example] Usage: python example.py [--app script.py] [-a arg1 arg2]")
sys.exit(2)
# ── Launch via Flatline ───────────────────────────────────────────────────
from flatline import Flatline, FlatlineConfig, _md5, VERSION, BUILD_DATE
print(f"Flatline Example — v{VERSION} ({BUILD_DATE})")
print(f"Supervising : {target}")
print(f"MD5 : {_md5(target)}")
print(f"Extra args : {app_args or '(none)'}")
print()
cfg = FlatlineConfig()
debugger = Flatline(config=cfg)
debugger.start()
print(f"[example] Relay port : {debugger._relayPort}")
print(f"[example] Socket REPL: nc localhost 5050")
print(f"[example] Ctrl+C to terminate child")
print()
def _sigint(sig, frame):
print("\n[example] Ctrl+C — terminating...")
debugger.terminate()
debugger.shutdown()
sys.exit(0)
signal.signal(signal.SIGINT, _sigint)
try:
debugger.launch([str(target)] + app_args)
exit_code = debugger.wait()
print(f"\n[example] Child exited: {exit_code}")
sys.exit(exit_code)
finally:
debugger.shutdown()Main debugger distribution.
Demo Qt application used to test output and crash behavior.
Programmatic usage example with pass-through CLI support.
Configurable freeze threshold, poll interval, app target, and database settings.
Bundled project documentation and help material.
Helper client for adding beat() events to your own application.
FlatLine is published under the MIT license and the package includes the demo app, example launcher, docs, and support files in one bundle.
Download FlatLine ZIP Direct ZIP Link Get the Package GitHub Repository
Need custom PHP or Python development? Reach out directly.
The package includes a fixhosts.py utility for toggling managed entries
in the Windows hosts file. It flips lines between active mappings like
127.0.0.1 example.test # auto and disabled mappings like
# auto: 127.0.0.1 example.test, making it easy to turn local vhosting
off and on without manually editing C:\Windows\System32\drivers\etc\hosts.
The script can target all managed entries or a named switch group, creates a backup before writing, requests elevation on Windows when needed, and flushes DNS after changes so the new host mappings take effect immediately.
import argparse
import ctypes
import os
import re
import shutil
import subprocess
import sys
import time
from dataclasses import dataclass
from pathlib import Path
from typing import Iterable
HOSTS = Path(r"C:\Windows\System32\drivers\etc\hosts")
AUTO_TAG = "# auto"
AUTO_PREFIX = "# auto:"
IP_LIKE_RE = re.compile(r"^(?:\d{1,3}(?:\.\d{1,3}){3}|::1|localhost)\b", re.IGNORECASE)
ACTIVE_RE = re.compile(
r"^(?P<indent>\s*)(?P<entry>.*?\S)\s+#\s*auto(?:\s*:\s*(?P<switch>[^#]+?))?\s*$",
re.IGNORECASE,
)
DISABLED_RE = re.compile(
r"^(?P<indent>\s*)#\s*auto\s*:\s*(?P<rest>.+?)\s*$",
re.IGNORECASE,
)
@dataclass
class ManagedLine:
indent: str
entry: str
switch: str | None
active: bool
@property
def domains(self) -> list[str]:
base = self.entry.split("#", 1)[0].strip()
parts = base.split()
if len(parts) < 2:
return []
return parts[1:]
@property
def switch_name(self) -> str:
return (self.switch or "default").strip() or "default"
@dataclass
class Change:
action: str
switch: str
domains: list[str]
before: str
after: str
def is_windows() -> bool:
return os.name == "nt"
def is_admin() -> bool:
if not is_windows():
return True
try:
return bool(ctypes.windll.shell32.IsUserAnAdmin())
except Exception:
return False
def quote_windows_arg(arg: str) -> str:
if not arg:
return '""'
if not re.search(r'[\s"]', arg):
return arg
escaped = arg.replace('\\', '\\\\').replace('"', '\"')
return f'"{escaped}"'
def relaunch_as_admin() -> None:
script = str(Path(__file__).resolve())
params = " ".join([quote_windows_arg(script), *[quote_windows_arg(a) for a in sys.argv[1:]]])
try:
rc = ctypes.windll.shell32.ShellExecuteW(None, "runas", sys.executable, params, None, 1)
except Exception as exc:
print(f"❌ Could not request elevation: {exc}")
raise SystemExit(1)
if int(rc) <= 32:
print("❌ UAC elevation was denied or failed.")
raise SystemExit(1)
raise SystemExit(0)
def flush_dns() -> None:
try:
completed = subprocess.run(
["ipconfig", "/flushdns"],
check=True,
capture_output=True,
text=True,
)
output = (completed.stdout or "").strip()
print(f"✅ DNS cache flushed.{(' ' + output) if output else ''}")
except Exception as exc:
print(f"⚠️ Could not flush DNS: {exc}")
def make_backup(path: Path) -> Path:
backup = path.with_name(path.name + ".fixhosts.bak")
shutil.copy2(path, backup)
return backup
def looks_like_entry(text: str) -> bool:
token = text.strip().split(None, 1)[0] if text.strip() else ""
return bool(token and IP_LIKE_RE.match(token))
def parse_disabled_rest(rest: str) -> tuple[str | None, str] | None:
rest = rest.strip()
if not rest:
return None
if looks_like_entry(rest):
return None, rest
if ":" in rest:
maybe_switch, maybe_entry = rest.split(":", 1)
maybe_switch = maybe_switch.strip()
maybe_entry = maybe_entry.strip()
if maybe_switch and maybe_entry and looks_like_entry(maybe_entry):
return maybe_switch, maybe_entry
return None
def parse_managed_line(line: str) -> ManagedLine | None:
active_match = ACTIVE_RE.match(line)
if active_match:
entry = active_match.group("entry").strip()
switch = active_match.group("switch")
return ManagedLine(
indent=active_match.group("indent") or "",
entry=entry,
switch=switch.strip() if switch else None,
active=True,
)
disabled_match = DISABLED_RE.match(line)
if not disabled_match:
return None
parsed = parse_disabled_rest(disabled_match.group("rest"))
if not parsed:
return None
switch, entry = parsed
return ManagedLine(
indent=disabled_match.group("indent") or "",
entry=entry.strip(),
switch=switch.strip() if switch else None,
active=False,
)
def render_line(item: ManagedLine) -> str:
if item.active:
if item.switch:
return f"{item.indent}{item.entry} {AUTO_TAG}: {item.switch}"
return f"{item.indent}{item.entry} {AUTO_TAG}"
if item.switch:
return f"{item.indent}{AUTO_PREFIX} {item.switch}: {item.entry}"
return f"{item.indent}{AUTO_PREFIX} {item.entry}"
def toggle_line(item: ManagedLine) -> ManagedLine:
return ManagedLine(
indent=item.indent,
entry=item.entry,
switch=item.switch,
active=not item.active,
)
def read_hosts_lines(path: Path) -> list[str]:
return path.read_text(encoding="utf-8", errors="replace").splitlines()
def write_hosts_lines(path: Path, lines: Iterable[str]) -> None:
path.write_text("\n".join(lines) + "\n", encoding="utf-8")
def print_summary(changes: list[Change], dry_run: bool) -> None:
if not changes:
print("ℹ️ No managed # auto lines were toggled.")
return
by_action: dict[str, dict[str, list[str]]] = {"ON": {}, "OFF": {}}
for change in changes:
bucket = by_action[change.action].setdefault(change.switch, [])
bucket.extend(change.domains or [change.before])
prefix = "🧪 Would turn" if dry_run else "✅ Turned"
for action in ("OFF", "ON"):
groups = by_action[action]
if not groups:
continue
print(f"{prefix} {action}:")
for switch, domains in groups.items():
unique_domains: list[str] = []
for domain in domains:
if domain not in unique_domains:
unique_domains.append(domain)
print(f" [{switch}]")
for domain in unique_domains:
print(f" - {domain}")
def toggle_hosts(path: Path, target_switch: str | None = None, dry_run: bool = False) -> int:
original_lines = read_hosts_lines(path)
new_lines: list[str] = []
changes: list[Change] = []
normalized_target = (target_switch or "").strip().lower()
for line in original_lines:
parsed = parse_managed_line(line)
if not parsed:
new_lines.append(line)
continue
switch_name = parsed.switch_name
if normalized_target and switch_name.lower() != normalized_target:
new_lines.append(line)
continue
toggled = toggle_line(parsed)
new_line = render_line(toggled)
new_lines.append(new_line)
changes.append(
Change(
action="ON" if toggled.active else "OFF",
switch=switch_name,
domains=parsed.domains,
before=line,
after=new_line,
)
)
if not changes:
print("ℹ️ Nothing matched.")
if normalized_target:
print(f" No managed entries were found for switch: {target_switch}")
else:
print(" No managed # auto entries were found.")
return 0
if dry_run:
print_summary(changes, dry_run=True)
return len(changes)
backup = make_backup(path)
write_hosts_lines(path, new_lines)
print(f"✅ Updated hosts file: {path}")
print(f"✅ Backup created: {backup}")
print_summary(changes, dry_run=False)
flush_dns()
return len(changes)
def build_parser() -> argparse.ArgumentParser:
parser = argparse.ArgumentParser(
description=(
"Toggle managed Windows hosts entries between active lines like "
"'127.0.0.1 example.com # auto' and disabled lines like "
"'# auto: 127.0.0.1 example.com'."
)
)
parser.add_argument(
"--hosts",
default=str(HOSTS),
help="Path to the hosts file. Defaults to the Windows hosts file.",
)
parser.add_argument(
"--switch",
dest="switch_name",
help=(
"Only toggle entries in one named switch group. "
"Active form: '127.0.0.1 x.com # auto: social' | "
"Disabled form: '# auto: social: 127.0.0.1 x.com'"
),
)
parser.add_argument(
"--dry-run",
action="store_true",
help="Show what would change without writing the file.",
)
return parser
def main() -> int:
parser = build_parser()
args = parser.parse_args()
hosts_path = Path(args.hosts)
print("Fixing hosts.")
time.sleep(1)
if not hosts_path.exists():
print(f"❌ Hosts file not found: {hosts_path}")
return 1
if is_windows() and not args.dry_run and not is_admin():
print("🔒 Hosts file needs admin rights. Requesting elevation...")
relaunch_as_admin()
try:
toggle_hosts(
path=hosts_path,
target_switch=args.switch_name,
dry_run=args.dry_run,
)
return 0
except PermissionError:
print("❌ Permission denied while writing the hosts file.")
if is_windows() and not is_admin():
print(" Run this as Administrator or accept the UAC prompt.")
return 1
except Exception as exc:
print(f"❌ Error: {exc}")
return 1
print("Fixing hosts.")
time.sleep(2)
if __name__ == "__main__":
raise SystemExit(main())
Death has been the one boundary no civilization has crossed. But human history is, in large part, the story of boundaries dissolving.
Practical Cryonics examines cryonics from three angles: the science of what modern vitrification can and cannot preserve; the ethics of whether extending the possibility of life is hubris, desperation, or moral responsibility; and the logistics of how individuals can think rationally about cost, risk, probability, and long-term outcomes without resorting to fantasy or denial.
This book does not promise immortality. It does not claim revival is guaranteed. It asks a narrower question: if death is a process rather than an event, and if that process can be interrupted — what follows from that possibility?
From anesthesia to antibiotics to organ transplantation, interventions once considered impossible have become ordinary. Each advance required a willingness to revise what counted as inevitable. The same question applies here.
Modern cryonic procedures do not freeze patients in the conventional sense. They use vitrification — a process in which bodily fluids achieve a glass-like state without the formation of ice crystals. The ice-crystal objection that most people raise against cryonics reflects a decades-old misunderstanding of the science, not its current state.
The book works through the physics of determinism and consciousness, the history of belief perseverance in medicine, the realistic pathway to revival through cloning rather than cell-by-cell repair, and the practical decisions an individual needs to make today to give cryonics its best chance of working.
"This is how humans are: We question all our beliefs, except for the ones that we really believe in, and those we never think to question."
— Orson Scott Card, Speaker for the Dead
For thousands of years, death was final. Then, in 1957, the first external defibrillation occurred — giving scientists the ability to restart hearts of patients who, a decade before, would have been pronounced dead. The technology did not become available everywhere overnight. Many people who could have been saved still died, as the medical establishment caught up to a new reality.
Cryonics is a bet — not a gamble. There are two parts. The first is the actual science of preserving a human body in a way that provides the best chance of future revival. That part can be done with science we have today. The second is a bet that future technology will make revival possible. People make bets like this constantly — when they invest in a biotech startup, or buy stock expecting next year's product will outperform this one.
I wrote Practical Cryonics for one simple reason: I have a daughter.
Eventually, it became obvious that the book I was looking for did not exist. So I wrote it.
At its core, Practical Cryonics reflects a simple conviction: if death is a process rather than an instantaneous event, and if future technology may one day reverse what medicine cannot today, then choosing preservation is not an act of desperation. It is an act of reason.
When I imagine the best possible future, it is not wealth or status that comes to mind. It is time. Time with the people I love. And if there is even a small chance to have more of it, that possibility is worth taking seriously.
For twenty years git has intentionally refused to follow symbolic links, for security reasons. git-symlinks ships the consent UX that mitigates the security objection: before any symlink is committed or resolved, the user sees the resolved absolute target, file count, and byte total, and approves per-repo. Opt-in, consent-based, future-proof. Plugin-API tool, no git patch required.
Three reference implementations ship side-by-side: Python, C++, and C. v0.1.1, MIT licensed, public on GitHub.
The readable, hackable implementation. Use this to understand the consent flow before reaching for the natives.
Drop-in native binary. Same consent UX, no Python runtime required.
Minimal, portable. Builds on Windows and Linux. Smallest footprint for CI containers.
Installs as a gh CLI extension so the consent flow becomes gh symlinks add.
Resolved target, file count, byte total surfaced before commit. Nothing follows a symlink without explicit per-repo consent.
Use it, fork it, ship it. No git patch required — it lives at the plugin-API layer.
git-symlinks on GitHub gh-symlinks extension
Need custom development or a deeper dive on the consent model? Get in touch.
Private business acquisition investment firm. We acquire profitable Main Street companies at disciplined valuations and distribute the income they produce to accredited investors.
Most investors are told that diversification means spreading money across stocks, bonds, and mutual funds. But experienced investors eventually discover something uncomfortable: most “diversified” portfolios still move with the same underlying force as the public markets. Real diversification comes from owning productive assets — assets that generate income because they provide real services to real customers.
Profitable small and mid-sized companies can often be acquired at 2–4× earnings, while many public companies trade at 15–30× earnings. That pricing gap exists because most buyers who would gladly acquire these businesses cannot access SBA financing or acquisition capital. That mismatch creates a market inefficiency where high-quality businesses with employees, customers, and real estate can still sell for 2.0–2.5× EBITDA with Debt Service Coverage above 2.0×.
ROI Comparison (2024–2025 data)
| Metric | Annual | Monthly |
|---|---|---|
| Acquisition Price | $2,000,000 | — |
| EBITDA Multiple | 2.5× | — |
| Gross Revenue | $1,400,000 | $116,667 |
| EBITDA | $800,000 | $66,667 |
| Annual Debt Service (SBA 7(a)) | $297,540 | $24,795 |
| DSCR | 2.69× ✓ | — |
| Net Distributable Cash Flow | $502,460 | $41,872 |
| Investor Return — $200K @ 16% | $32,000 | $2,667 |
Compounded Returns — 16% (blue) vs. S&P 500 ~10% (red)
Call or Text: (724) 431-5207
Email: invest@acquisitioninvest.com
Address: 510 Main Street, Prospect, PA 16052
† This section is for informational purposes only and does not constitute an offer to sell securities. All returns are projected and not guaranteed. Investing in private placements involves risk, including loss of principal. Available to accredited investors only.
Most business owners leave money on the table when they sell. Not because their business isn't worth more — because it isn't packaged, positioned, or prepared the way buyers and lenders need to see it.
We fix that. Before you go to market.
FullPriceExit is a pre-acquisition (pre-sale) consulting practice. We work with business owners before they go to market — cleaning up the financials, fixing the story, preparing the diligence package, and structuring the deal so that serious buyers can actually get SBA financing approved.
We don't just sell billable hours. We sell results. Every owner, every company, every deal is different — so the approach is tailored to the real-world needs of your business, your numbers, your timing, and your goals.
Thousands today can net you hundreds of thousands at sale.
Owner goals interview, baseline valuation, buyer-type targeting, go-to-market plan, and readiness scorecard. Sets expectations and deal strategy before anyone sees your numbers.
GAAP cleanup, owner add-backs, normalized EBITDA, revenue quality review, working capital analysis, AR/AP hygiene. Reveals true earnings and removes red flags before buyers find them.
SOPs, org charts, IT asset inventory, password vault, MFA rollout, DNS hardening, email migration, backups, and a full “Buyer Tech Pack.” Transferability is value.
Teaser, NDA, CIM (Confidential Information Memorandum), SBA-friendly lender pack, diligence workspace, management presentation, LOI comparison, and transition plan.
Minute book, cap table, contract audit, lease and landlord estoppel readiness, license and permits, IP audit. No surprises in diligence.
CRM cleanup, customer concentration mitigation, pricing and margin quick wins, brand and web audit, LTV/CAC narrative. Turn marketing spend into valuation.
Not sure if we're the right fit? That's exactly the point of a conversation.
Call: (724) 431-5207
Website: fullpriceexit.com
Address: 250 Mt. Lebanon Blvd, STE 210, Pittsburgh, PA 15234
Fax: (412) 550-3742
Photo by Dllu, licensed CC BY-SA 4.0, via Wikimedia Commons.
Pittsburgh sits where the Allegheny and Monongahela rivers come together to form the Ohio, and that confluence has shaped the city for centuries — first as a strategic fort, then as the steel capital of the world, and today as a hub for healthcare, robotics, education, and technology. The skyline still carries echoes of its industrial past, but the economy underneath it has changed almost completely.
What I find most interesting about Pittsburgh is how many distinct neighborhoods it's made of — dozens of them, each with its own identity, business district, and local character. That makes it a great market for small and mid-sized businesses: a shop in Lawrenceville and a shop in Squirrel Hill are competing in completely different micro-markets, even though they're a few miles apart.
The city's universities and hospital systems also mean there's a steady churn of new residents, students, and professionals looking for local services online — which makes local SEO and a fast, mobile-friendly website more valuable here than in a lot of places.
I'm based right in the Pittsburgh area, and I work with city businesses on everything from custom web applications to SEO-focused websites and marketing automation. If you run a business in Pittsburgh proper and want a site that actually ranks and converts — or a custom tool that replaces a spreadsheet-and-email mess — get in touch and let's talk about what you need.
Get in Touch
Photo by Lee Paxton, licensed CC BY-SA 4.0, via Wikimedia Commons.
The North Hills is the broad band of suburban communities directly north of the city of Pittsburgh, including townships like Ross, McCandless, and Shaler. It's one of the most densely populated suburban areas in the region, with a mix of established mid-century neighborhoods and newer commercial corridors along routes like McKnight Road and Babcock Boulevard.
Because it's so close to downtown and the airport corridor, the North Hills has long been a popular base for professionals who work in the city but want more space and good schools. That's translated into a strong concentration of retail, medical offices, and professional services — which means a lot of local competition for search visibility.
For businesses here, the North Hills market rewards a strong local presence: clear service-area pages, accurate map listings, and a site that loads fast on mobile, since so much of the search traffic in this corridor comes from people searching on the go between errands along McKnight Road or Route 19.
If your business serves the North Hills — Ross Township, McCandless, Shaler, or anywhere along the McKnight Road corridor — I can build you a website and local SEO setup that helps you show up when nearby customers search for what you do. I also build custom internal tools if your business has outgrown spreadsheets. Reach out and let's talk about your project.
Get in Touch
Photo by Nyttend, public domain, via Wikimedia Commons.
Wexford is an unincorporated community in Pine Township, Allegheny County, sitting along the Route 19 corridor a bit further out from the city than the core North Hills. It's grown rapidly over the last few decades into one of the more affluent suburban markets north of Pittsburgh, with a mix of corporate offices, medical campuses, and upscale retail centers.
The Wexford area benefits from its position near I-79 and the Pennsylvania Turnpike, which has made it attractive to companies that need easy access to both the city and points north toward Butler County. That accessibility, combined with newer housing developments, has brought in a steady stream of new residents and businesses over the past twenty years.
For local businesses, that growth means the market is still relatively open compared to more saturated parts of the city — there's real opportunity for a well-built local site to capture search traffic from people who recently moved into the area and are looking for everything from contractors to dentists to restaurants.
If you run a business in Wexford or the Route 19 corridor in Pine Township, I can help you build a website that's set up to capture local search traffic from this growing market — plus any custom software or automation your business needs behind the scenes. Contact me to get started.
Get in Touch
Photo by brewbooks, licensed CC BY-SA 2.0, via Wikimedia Commons.
Cranberry Township sits in southern Butler County, right where I-79 and I-76 (the Pennsylvania Turnpike) meet — a location that's made it one of the fastest-growing commercial centers in the Pittsburgh region. What was once mostly farmland is now home to corporate campuses, large retail centers, and a steady wave of new housing developments.
The township operates its own local government services and has invested heavily in parks, trails, and infrastructure, which has helped it attract both families and businesses relocating from closer-in suburbs. It's become something of a self-contained commercial hub in its own right, rather than just a bedroom community for Pittsburgh.
That growth creates a competitive but rewarding local search market — new residents and new businesses are constantly searching for local services, and a well-optimized site can capture a meaningful share of that traffic if it's built right from the start.
Cranberry Township is one of the fastest-growing markets in the Pittsburgh area, and I help local businesses here build websites and SEO strategies that keep pace with that growth — plus custom software for businesses that need more than an off-the-shelf tool can offer. Get in touch if you want to talk about your site or your systems.
Get in Touch
Photo by Mvincec, public domain, via Wikimedia Commons.
The city of Butler is the county seat of Butler County, located about 35 miles north of Pittsburgh. It has a long industrial history — it was a major center for oil-field equipment manufacturing in the late 1800s and early 1900s, and at one point was home to companies that built some of the first armored vehicles in the country.
Butler County itself stretches from the edge of the Pittsburgh metro area up into more rural farmland, which means it covers a wide range of markets: dense suburban communities near Cranberry and Mars, the more traditional small-city core of Butler itself, and rural townships further out where local businesses often serve a wider geographic radius.
That range means there's no one-size-fits-all approach to local SEO here — a business in downtown Butler is competing in a different way than one in the Cranberry corridor. A good local strategy accounts for both the city's historic downtown business district and the county's broader, more spread-out customer base.
Whether you're located in downtown Butler or out in one of the county's smaller communities, I build websites and local SEO setups tailored to how people actually search in your part of Butler County — plus custom software if your business needs something built specifically for how you work. Contact me to discuss your project.
Get in Touch
Photo by Brastins, licensed CC BY-SA 3.0, via Wikimedia Commons.
Fox Chapel is one of the most affluent communities in the Pittsburgh region, located along the Allegheny River northeast of the city. It's known for large wooded lots, winding roads, and a deliberately low-density character — the borough has long restricted commercial development to keep its residential feel, which means most of its business activity is concentrated in professional services, healthcare, and a handful of specialty retailers.
The broader Allegheny Valley around Fox Chapel includes communities like Aspinwall, Sharpsburg, and O'Hara Township, which have a more traditional small-town commercial mix — local restaurants, shops, and service businesses along walkable main streets that have seen renewed investment in recent years.
Because Fox Chapel itself has limited commercial space, businesses serving this area often draw clients from a wider radius across the Allegheny Valley. A website built for this market needs to speak to that broader audience while still signaling the kind of quality and professionalism that Fox Chapel clients expect.
I work with businesses serving Fox Chapel and the Allegheny Valley — from Aspinwall to Sharpsburg to O'Hara Township — building websites and SEO that match the level of professionalism clients in this area expect, along with any custom software your business needs. Reach out to talk about your project.
Get in Touch
Photo by Ctoocheck (English Wikipedia), licensed CC BY-SA 3.0, via Wikimedia Commons.
Pittsburgh's East End is a collection of some of the city's most well-known neighborhoods — East Liberty, Shadyside, Squirrel Hill, Friendship, Bloomfield, and Garfield among them. It's one of the most walkable and densely populated parts of the city, with a mix of historic housing stock, university-adjacent neighborhoods, and busy commercial corridors like Walnut Street and Murray Avenue.
East Liberty in particular has gone through a major transformation over the past two decades, shifting from a struggling commercial district into one of the city's most active retail and tech-adjacent business corridors. Shadyside and Squirrel Hill, meanwhile, have maintained their reputations as upscale, established neighborhood business districts with loyal local customer bases.
For businesses in the East End, foot traffic and neighborhood loyalty still matter, but so does showing up online for people searching from nearby — university students, young professionals, and longtime residents alike all rely heavily on search and maps to find local businesses in this part of the city.
I help businesses across Pittsburgh's East End — East Liberty, Shadyside, Squirrel Hill, Bloomfield, and the surrounding neighborhoods — build websites and local SEO that connect with the dense, search-savvy population in this part of the city, plus custom software for businesses that need more than a template site. Get in touch to discuss your needs.
Get in Touch
Photo by Avicennasis, licensed CC BY-SA 3.0, via Wikimedia Commons.
Monroeville is a large suburban municipality east of Pittsburgh, sitting at the crossroads of I-376 (the Penn-Lincoln Parkway) and the Pennsylvania Turnpike. That location made it a natural hub for retail development starting in the 1960s and 70s, and it's still home to one of the region's major shopping malls along with a wide mix of big-box retail, restaurants, and office space.
Beyond the commercial corridors along Route 22 and William Penn Highway, Monroeville and the surrounding eastern suburbs — places like Churchill, Forest Hills, and Penn Hills — have a strong base of established residential neighborhoods, many built up during the post-war suburban expansion.
Because so much of the eastern suburbs' commercial activity is concentrated along a few major roads, local search results for this area can be crowded with larger chains. That makes it especially important for independent and small businesses here to have a well-optimized site that highlights what makes them different from the big retailers nearby.
If you run a business in Monroeville or the eastern Pittsburgh suburbs, I can help your website stand out in a market that's often dominated by larger chains — with local SEO that highlights what makes your business different, plus custom software if you need it. Contact me to talk about your project.
Get in Touch
Photo by Designism, CC0, via Wikimedia Commons.
The Lower Allegheny Valley refers to the string of riverside communities along the Allegheny River just upstream from Pittsburgh, including towns like Oakmont, Verona, and Penn Hills' river-adjacent sections. Oakmont in particular is well known well beyond the region as the home of a historic golf club that has hosted multiple U.S. Opens, giving the area a recognizable identity tied to golf and classic small-town charm.
These river towns developed in the 19th century around the railroads and river traffic that once dominated the valley, and many of their downtown business districts still reflect that era — walkable main streets with a mix of older buildings now occupied by local restaurants, shops, and service businesses.
The Lower Allegheny Valley sits in an interesting spot: close enough to Pittsburgh and the Parkway East for an easy commute, but with a small-town feel that residents value and that local businesses can lean into when marketing to their community.
I work with businesses in the Lower Allegheny Valley — Oakmont, Verona, and the surrounding river towns — to build websites and local SEO that reflect the small-town character residents value, while still making sure you're found by people searching from nearby. Get in touch to talk about your site or systems.
Get in Touch
Photo by Pittsburgh7 (English Wikipedia), public domain, via Wikimedia Commons.
The South Hills is the large cluster of hilly suburban neighborhoods and municipalities directly south of Pittsburgh's downtown, across the Monongahela River. It includes well-established communities like Mt. Lebanon, Bethel Park, Brookline, and Castle Shannon — many of which were among the first streetcar suburbs to develop in the early 1900s as rail lines extended out from the city.
That streetcar history is still visible today: several South Hills communities have walkable, traditional business districts centered around what were once trolley stops, alongside newer commercial development along busier roads like Route 19 and Banksville Road. The light-rail line that runs through parts of the South Hills remains one of the only true rail transit connections to downtown Pittsburgh.
The South Hills is a market where reputation and local word-of-mouth still carry a lot of weight, but it's also a place where residents are increasingly searching online first — which makes it valuable for local businesses to make sure their digital presence matches the trust they've built in the community.
I'm based in the South Hills myself, and I work with local businesses here — Mt. Lebanon, Bethel Park, Castle Shannon, and the surrounding communities — on websites, SEO, and custom software that help you reach both longtime neighbors and new residents searching online. Contact me to get started.
Get in Touch
Photo by Generic1139, licensed CC BY-SA 3.0, via Wikimedia Commons.
Peters Township sits in northern Washington County, just south of the Allegheny County line along Route 19. Over the past few decades it has grown into one of the more desirable suburban communities in the South Hills region, known for highly rated schools and a steady pace of new residential development.
That growth has brought a wave of newer retail and commercial development along the Route 19 corridor, alongside the township's older rural and small-town roots. Northern Washington County more broadly has benefited from its proximity to both Pittsburgh and the South Hills, making it an attractive spot for businesses that want to serve a growing suburban population without being in the thick of denser city neighborhoods.
For local businesses, Peters Township and the surrounding area represent a market full of relatively new residents who are actively searching for everything from healthcare providers to home services as they settle into the community — which is exactly the kind of search activity a well-built local site can capture.
If your business serves Peters Township or northern Washington County, I can help you build a website and local SEO presence that connects with the steady stream of new residents searching for local services in this growing area — plus custom software if your business needs it. Reach out to discuss your project.
Get in Touch
Photo by Ronjamin (English Wikipedia), licensed CC BY-SA 2.5, via Wikimedia Commons.
The Mon Valley refers to the string of river towns along the Monongahela River south and east of Pittsburgh — communities like McKeesport, Clairton, Duquesne, Monessen, and Donora, among others. For most of the 20th century this was one of the most heavily industrialized stretches of the steel industry, with mills running almost continuously along the riverbanks.
The decline of steel manufacturing hit the Mon Valley harder than most parts of the region, and many of these towns have spent decades working through that transition — some with notable success in redeveloping former industrial sites, others still working to rebuild their commercial cores. What remains consistent across the valley is a strong sense of local identity and community pride, even in towns that have seen population decline.
For businesses in the Mon Valley, that means local loyalty can be a real asset, but it also means competing for attention in a market where many residents commute elsewhere for work and shopping. A solid local web presence can help Mon Valley businesses capture customers who might otherwise default to searching for options closer to where they work.
I work with businesses throughout the Mon Valley — McKeesport, Clairton, Duquesne, Monessen, Donora, and the other river towns — to build websites and local SEO that help you reach both longtime residents and people searching from outside the valley, plus any custom software your business needs. Contact me to talk about your project.
Get in Touch
Photo by Mr. Matte, licensed CC BY-SA 4.0, via Wikimedia Commons.
The area around Pittsburgh International Airport, in Findlay Township and the surrounding western suburbs, has become one of the more dynamic commercial corridors in the region. The airport itself anchors a growing cluster of logistics, distribution, and corporate facilities, and the surrounding townships — including Robinson and North Fayette — have seen significant retail and hospitality growth along the Route 60 and Steubenville Pike corridors.
Robinson Township in particular has developed into one of the largest retail destinations in the Pittsburgh region, drawing shoppers from across the metro area as well as travelers passing through the airport. That mix of local residents, regional shoppers, and business travelers creates a uniquely broad customer base for businesses in this corridor.
For businesses here, local SEO has to work on two levels — capturing nearby residents searching for everyday services, while also being visible to the steady stream of visitors and travelers who pass through the area and search for things to do, eat, or buy near the airport.
If your business is near Pittsburgh International Airport or in the western suburbs like Robinson Township or North Fayette, I can help you build a website and SEO strategy that reaches both local residents and the travelers passing through this busy corridor — plus custom software if you need it. Get in touch to discuss your project.
Get in Touch
Photo by Tim Tierney, licensed CC BY-SA 4.0, via Wikimedia Commons.
Sewickley is a borough along the Ohio River northwest of Pittsburgh, known for its well-preserved historic downtown and a long-standing reputation as one of the region's more affluent communities. Its main commercial street is lined with independent shops, restaurants, and boutiques that have managed to thrive even as larger retail has consolidated elsewhere.
The broader Quaker Valley area — which takes its name from the local school district and includes communities like Edgeworth, Leetsdale, and parts of Aleppo and Bell Acres townships — shares that small-town, river-valley character. The area's history is tied closely to the Ohio River and the rail lines that once ran along it, and many of its neighborhoods retain a distinctly historic feel.
For businesses in Sewickley and the Quaker Valley, the local market rewards a polished, professional online presence — residents here tend to research thoroughly before choosing a service provider, and a well-built website can be the deciding factor between a quick inquiry and a lost lead.
I work with businesses in Sewickley and the Quaker Valley area to build websites and local SEO that match the polished, research-driven expectations of this market, along with custom software for businesses that need it. Contact me to talk about your project.
Get in Touch
Photo by Nyttend, public domain, via Wikimedia Commons.
Beaver County sits at the northwestern edge of the Pittsburgh metro area, where the Beaver and Ohio Rivers meet. Like much of the region, it has a deep industrial history — towns like Aliquippa and Ambridge grew up around major steel and manufacturing operations in the early 20th century, and the county's identity is still shaped by that legacy even as its economy has diversified.
More recently, Beaver County has seen significant investment tied to the natural gas and petrochemical industry, including a major manufacturing facility along the Ohio River that has brought new jobs and economic activity to the area. Alongside that, towns like Beaver and Bridgewater have maintained charming, well-preserved downtown areas that draw visitors from across the region.
For local businesses, Beaver County represents a market in transition — one with deep community roots and loyal customer bases in its established towns, plus new growth tied to recent industrial investment that's bringing new residents and workers into the area.
I work with businesses throughout Beaver County — from Beaver and Bridgewater to Aliquippa, Ambridge, and the surrounding communities — to build websites and local SEO that connect with both longtime residents and the newer population moving into the area, plus custom software if your business needs it. Reach out to discuss your project.
Get in Touch
Photo by WeaponizingArchitecture, licensed CC BY-SA 4.0, via Wikimedia Commons.
Washington, Pennsylvania is the county seat of Washington County, located southwest of Pittsburgh along I-79 and historic U.S. Route 40 (the old National Road). The city has a long history dating back to the colonial era, and its downtown still reflects that — a grid of historic buildings, many tied to the city's role as an early transportation hub between the East Coast and the western frontier.
Washington is also home to a well-regarded private college, which brings a steady population of students and faculty into the local economy alongside the city's longtime residents. The surrounding county has seen significant economic activity tied to the natural gas industry over the past two decades, which has brought new business activity to the broader southwestern region.
For businesses in Washington and the deeper southwest, the local market combines an established residential and institutional base with newer commercial activity tied to energy-sector growth — meaning there's both a stable local customer base and an influx of newer searchers looking for services in the area.
If your business serves Washington, PA or the deeper southwest Pittsburgh region, I can help you build a website and local SEO presence that reaches both the city's established community and the newer population tied to the area's growth, plus custom software if you need it. Contact me to talk about your project.
Get in Touch
Photo by David Fulmer, licensed CC BY-SA 2.0, via Wikimedia Commons.
Greensburg is the county seat of Westmoreland County, located along the historic Lincoln Highway east of Pittsburgh. Its downtown is anchored by a notable courthouse and a mix of historic commercial buildings, and the city has worked over the years to keep that downtown core active even as commercial development has spread out along the surrounding highways.
Westmoreland County as a whole is one of the larger counties in the Pittsburgh metro area, stretching from suburban communities close to the city out to more rural areas further east. It has its own community college and a regional hospital network, both of which help anchor the local economy alongside a mix of manufacturing, retail, and service businesses.
For businesses in Greensburg and the surrounding Westmoreland communities, the market includes both a traditional downtown customer base and a more spread-out suburban and rural population — meaning a local website needs to be findable both by people searching within the city and by those searching from further out in the county.
I work with businesses in Greensburg and across Westmoreland County to build websites and local SEO that reach both the downtown customer base and the broader county population, plus custom software for businesses that need something built specifically for how they operate. Get in touch to discuss your project.
Get in Touch
Photo by Doug Kerr, licensed CC BY-SA 2.0, via Wikimedia Commons.
Armstrong County sits along the Allegheny River north and east of Pittsburgh, marking the northern edge of the metro region. The county seat, Kittanning, sits directly on the river and has a downtown shaped by its history as a hub for river and rail transportation in the 19th century.
Like much of the broader region, Armstrong County's economy was historically tied to coal mining and related industries, and many of its smaller towns grew up around those operations. Today the county is more rural in character than the suburban communities closer to Pittsburgh, with agriculture, small manufacturing, and local services forming the backbone of its economy.
For businesses on this northern fringe of the Pittsburgh region, the local market often covers a wider geographic area than in denser suburbs — customers may be spread across multiple small towns and rural areas, which makes a strong, easy-to-find online presence especially valuable for reaching people who don't have a lot of nearby options.
If your business serves Armstrong County or the northern fringe of the Pittsburgh region — Kittanning and the surrounding river and rural communities — I can help you build a website and local SEO presence that makes it easy for spread-out customers to find you, plus custom software if your business needs it. Contact me to talk about your project.
Get in TouchEffective Date: June 3, 2026
Trent Tompkins ("we," "us," or "our") respects your privacy. This Privacy Policy explains what personal information we collect through trentontompkins.com and any related website, app, store, or service we operate (the "Services"), how we use and protect it, when we share it, and the choices and rights you have. By using the Services you agree to this Policy. It works together with our Terms of Service, which govern your use of the Services and include the full terms of our text-messaging program.
What we collect depends on how you interact with us. Not every category applies to every person.
If you opt in to text messages from Trent Tompkins, the following applies. Full SMS terms are in our Terms of Service.
No mobile information — including text-messaging opt-in data and consent — will be sold, rented, or shared with any third parties or affiliates for marketing or promotional purposes. The categories of sharing described in the next section specifically exclude your SMS opt-in data and consent; that information is shared only with the communications providers we use to deliver the messages you requested, and only as needed to deliver them.
We do not sell your personal information. We share it only in these limited ways:
For the avoidance of doubt: mobile opt-in data and consent are never shared with third parties or affiliates for their own marketing or promotional purposes.
We do not sell or "share" personal information for cross-context behavioral advertising as those terms are defined under the California Consumer Privacy Act (CCPA/CPRA) or other U.S. state privacy laws, and we have not done so in the preceding 12 months.
We keep personal information only as long as needed for the purposes above, to comply with legal, tax, and accounting obligations, and to resolve disputes — then we delete or anonymize it. Opt-in/opt-out records are kept as long as required to honor your messaging preferences and demonstrate compliance.
We use administrative, technical, and physical safeguards — including encryption in transit (HTTPS), hashed passwords, and access controls — to protect your information. No method of transmission or storage is 100% secure, but we work to protect your data and review our practices.
Depending on where you live, you may have the right to access, correct, delete, or port your personal information; to opt out of marketing; and to not be discriminated against for exercising these rights.
To exercise any right, contact us using the details under Contact. We will verify your request and respond within the time required by applicable law.
We use strictly necessary cookies to run the Services and optional cookies to remember preferences and measure usage. You can control cookies through your browser settings; disabling some may affect functionality.
The Services are not directed to children under 13, and we do not knowingly collect personal information from anyone under 13 (COPPA). If you believe a child has provided us personal information, contact us and we will delete it.
We operate in the United States. If you access the Services from outside the U.S., you understand your information will be processed in the U.S., where privacy laws may differ from those in your country.
We may update this Policy from time to time. We will post the revised version here with a new Effective Date and, where required, provide additional notice.
Questions about this Policy or your information? Reach us at:
See also our Terms of Service.
Effective Date: June 3, 2026
IMPORTANT — PLEASE READ. THESE TERMS CONTAIN A BINDING ARBITRATION AGREEMENT AND A CLASS ACTION & JURY-TRIAL WAIVER (SEE THE "BINDING ARBITRATION" AND "CLASS ACTION & JURY TRIAL WAIVER" SECTIONS BELOW). BY ACCESSING OR USING THE SERVICES, YOU AGREE TO RESOLVE DISPUTES WITH TRENT TOMPKINS ON AN INDIVIDUAL BASIS THROUGH ARBITRATION, YOU WAIVE YOUR RIGHT TO A JURY TRIAL AND TO PARTICIPATE IN ANY CLASS ACTION, AND YOU USE THE SERVICES AT YOUR OWN RISK ("AS IS," WITHOUT WARRANTIES).
Welcome to Trent Tompkins. These Terms of Service ("Terms") govern your use of trentontompkins.com and any related website, app, store, or service we operate (the "Services"). By accessing or using the Services you agree to these Terms and to our Privacy Policy. If you do not agree, do not use the Services.
"Trent Tompkins," "we," "us," or "our" refers to the operator of the Services. You can reach us using the details under Contact below.
You must be at least 13 years old to use the Services, and at least 18 (or the age of majority where you live) to make purchases or enter agreements. If you are under 18 you may use the Services only with a parent or guardian's consent.
You are responsible for keeping your login credentials secure and for all activity under your account. Provide accurate information and keep it current. We may suspend or terminate accounts that violate these Terms.
You agree not to misuse the Services, including by: violating any law; infringing others' rights; uploading malware; attempting to gain unauthorized access; scraping or overloading the Services; or harassing other users. We may remove content or restrict access for violations.
By opting in, you agree to receive recurring text messages from Trent Tompkins at the mobile number you provide. Consent is not a condition of any purchase.
How we handle mobile data is described in our Privacy Policy. Mobile opt-in data and consent are never shared with third parties or affiliates for their marketing or promotional purposes.
Prices and availability may change. Payment-card processing is handled by our third-party payment processor. You agree to pay all charges incurred. We may refuse or cancel orders (e.g., suspected fraud or pricing errors). Refund eligibility, if any, is described at checkout or on the relevant product page.
The Services and all content we provide are owned by us or our licensors and protected by intellectual-property laws. We grant you a limited, personal, non-exclusive, non-transferable, revocable license to use the Services for their intended purpose. You retain rights to content you submit but grant us a license to host and display it as needed to operate the Services.
THE SERVICES ARE PROVIDED "AS IS" AND "AS AVAILABLE," WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. We do not warrant that the Services will be uninterrupted, secure, or error-free.
TO THE FULLEST EXTENT PERMITTED BY LAW, TRENT TOMPKINS AND ITS OWNERS, OFFICERS, AND AGENTS WILL NOT BE LIABLE FOR ANY INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL, OR PUNITIVE DAMAGES, OR ANY LOSS OF PROFITS, DATA, OR GOODWILL, ARISING FROM YOUR USE OF THE SERVICES. OUR TOTAL LIABILITY FOR ANY CLAIM WILL NOT EXCEED THE GREATER OF (A) THE AMOUNT YOU PAID US IN THE 12 MONTHS BEFORE THE CLAIM, OR (B) USD $100.
You agree to indemnify and hold harmless Trent Tompkins from any claims, damages, and expenses (including reasonable attorneys' fees) arising out of your use of the Services or your violation of these Terms.
Please read this section carefully — it affects how disputes are resolved. Except for the carve-outs below, you and Trent Tompkins agree that any dispute, claim, or controversy arising out of or relating to these Terms or the Services will be resolved by final and binding arbitration administered by the American Arbitration Association (AAA) under its Consumer Arbitration Rules, rather than in court. The arbitration will be conducted in Allegheny County, Pennsylvania, or by phone/video where the rules allow, and judgment on the award may be entered in any court of competent jurisdiction. Carve-outs: either party may bring an individual claim in small-claims court, and either party may seek injunctive relief in court to protect intellectual property.
YOU AND TRENT TOMPKINS AGREE THAT EACH MAY BRING CLAIMS AGAINST THE OTHER ONLY IN AN INDIVIDUAL CAPACITY, AND NOT AS A PLAINTIFF OR CLASS MEMBER IN ANY PURPORTED CLASS, CONSOLIDATED, OR REPRESENTATIVE PROCEEDING. YOU AND WE WAIVE ANY RIGHT TO A JURY TRIAL. The enforceability, scope, and validity of this waiver shall be decided by a court of competent jurisdiction and not by an arbitrator. If this Class Action Waiver is found unenforceable as to a particular claim, then the Binding Arbitration section shall be null and void as to that claim only, and that claim shall proceed in the courts identified below — but the waiver shall remain in full force for all other claims.
These Terms are governed by the laws of the Commonwealth of Pennsylvania, without regard to its conflict-of-laws rules. For any dispute not subject to arbitration, you and Trent Tompkins agree to the exclusive jurisdiction and venue of the state and federal courts located in Allegheny County, Pennsylvania, and you waive any objection to such venue.
We may update these Terms from time to time. We will post the revised version here with a new Effective Date. Continued use of the Services after changes take effect constitutes acceptance.
If any provision of these Terms is held unenforceable, the remaining provisions will remain in full force and effect.
See also our Privacy Policy.