DEV Community: Spencer Marx

Latest post hopefully helps some of you guys looking for a more structured automated code review process. Free, Open Source, and community driven 100%. Check it out and get up and running in less than 5 min 💪

Spencer Marx — Mon, 06 Apr 2026 14:00:07 +0000

Spencer Marx

Apr 6

The tool that stops 10x more AI slop than anything else my team has tried. Open source, FREE, and growing 🚀

#opensource #ai #claudecode #opencode

Comments

3 min read

The tool that stops 10x more AI slop than anything else my team has tried. Open source, FREE, and growing 🚀

Spencer Marx — Mon, 06 Apr 2026 13:58:58 +0000

AI slop doesn't crash your app. It passes your tests, your linters, your type checks. It looks like code a competent person wrote. Then three weeks later you're staring at a service full of abstractions that exist for no reason, functions that do the same thing behind slightly different signatures, and variable names that technically make sense but communicate nothing to the next person reading them.

That's the version of slop nobody talks about. The kind that compounds.

How this started

I've been writing software for a long time. IC, staff, principal, EM, director, now CTO. When AI coding assistants became part of our daily workflow I started doing something that felt almost paranoid at first: after an agent finished implementing something, I'd spin up separate Claude Code agents to review the output, each with a different focus area. One looking at architecture, one at security, one at quality.

It worked. Way better than single-pass review. But it was completely ad-hoc. I'd manually prompt each reviewer, mentally track who said what, try to reconcile conflicting findings in my head.

So I started structuring it. I gave each reviewer a defined role and explicit focus areas, and I ran them in parallel instead of sequentially. Then I added a step that changed everything: after the individual reviews, I had the reviewers talk to each other. They'd challenge findings, connect issues one reviewer found with something another reviewer flagged in a different file, push back on false positives, and reach consensus.

Over a few weeks this turned into custom slash commands. Over a few months it became a real system. And when it came time to standardize the workflow across our engineering team and stop being dependent on one specific CLI tool, Open Code Review was born.

What it actually does

Under the hood, OCR is really just a set of bootstrapped slash commands, markdown reference files, and orchestration rules that allow your native agentic CLI to perform structured multi-agent review. You configure a team of specialized reviewer agents (architect, security, quality, QA, whatever custom reviewers make sense for your codebase) and they review the PR independently, in parallel, with intentional overlap.

Then they deliberate.

It's a structured discourse where they challenge each other's findings, connect related issues across files, and reach actual consensus. One synthesized review comes out the other end. Not five separate opinions, but a team opinion that's been pressure-tested before you ever see it.

There's a local dashboard on top of all this that makes the whole process visible and easy to follow in real time. When it's done you post the review straight to your GitHub PR.

That deliberation step is the thing. I've seen other multi-agent approaches where each reviewer just dumps findings independently. That's parallel linting. The structured debate between reviewers with genuinely different concerns is where the signal lives.

Try it

Every feature in OCR exists because I hit a wall without it while doing this manually. It grew out of months of ad-hoc multi-agent reviews, and I automated away every piece of friction incrementally.

It's also agentic-CLI agnostic. It started in Claude Code but works standalone with Codex, Gemini CLI, Cursor, Windsurf, Copilot, whatever you're using. That was a hard requirement when we open-sourced it because locking a review tool to one assistant's ecosystem felt wrong.

npm install -g @open-code-review/cli
cd your-project
ocr init

Two minutes to get started. Free. Open source. No SaaS. No per-seat pricing. Reviewer teams are fully customizable or just use the defaults.

➡️ GitHub: github.com/spencermarx/open-code-review

If OCR helps your workflow, a GitHub star helps other engineers dealing with the same slop problem find it. And if you run into rough edges or have ideas for how it should work differently, open an issue. The feedback loop from actual users has shaped this tool more than anything else 💪

If you've found other code review approaches that actually work well with AI-generated code, I'd love to hear about those too.

Cheers and Happy Reviewing 🚀

RELEASE THE HORDE!! 🤖 Haha, but seriously, for fans (or anti-fans) of Gastown, this one is for you... a simple lightweight orchestration engine that drops in, can manage any number of your projects, and stays out of the way. 5 min to get up and running 💪

Spencer Marx — Thu, 19 Mar 2026 16:15:27 +0000

Spencer Marx

Mar 19

Release the Horde: Multi-Agent Orchestration in Pure Bash

#ai #opensource #bash #devtools

Comments 3

3 min read

Release the Horde: Multi-Agent Orchestration in Pure Bash

Spencer Marx — Thu, 19 Mar 2026 16:10:12 +0000

Anyone running 3+ AI coding agents in parallel has hit the same wall: the agents are fine. The coordination is the problem.

Merge conflicts. Duplicated work. No review gate. Token burn on orchestration overhead. You end up spending more time managing agents than the agents save you.

So I built Orc.

What it does

You describe the work. Orc decomposes it into goals and beads (focused work items), spawns engineers in isolated git worktrees, reviews everything before merge, and delivers clean goal branches.

Across multiple projects, from a single session.

"Fix auth, add rate limiting, update docs"
                  │
                  ▼
          ┌──── orc ────┐
          │      │      │
          ▼      ▼      ▼
    fix/auth  feat/rate  task/docs      ← goal branches
      │   │      │         │
     [E] [E]    [E]       [E]           ← engineers in isolated worktrees
      │   │      │         │
     ✓/✗ ✓/✗    ✓/✗       ✓/✗           ← built-in review loop
      │   │      │         │
    fix/auth  feat/rate  task/docs      ← approved beads merge back
          │      │         │
          You review & merge            ← you decide when to ship

The whole stack

Bash. Tmux. Git worktrees.

No daemon. No server. No framework. No build step. State is three files. You're running in five minutes.

# Register a project
orc add myapp /path/to/myapp

# Launch
orc myapp

# Or go full send
orc myapp --yolo

Opinionated but stays out of your way

This is where it gets interesting. Orc has strong opinions about structure (four-tier hierarchy, mandatory review before merge, hard role boundaries), but the things you actually care about customizing are wide open.

The review loop is mandatory. How you review is yours. Swap in your own review command, point it at a multi-agent review tool, or just describe your review standards in plain English:

[review]
command = "/ocr:review"  # your tool, or leave blank for built-in

instructions = """
Focus on security: check for SQL injection, XSS, and auth bypass.
All new endpoints must have rate limiting.
Verify error responses follow our RFC 7807 format.
"""

Branch naming? Natural language:

[branching]
strategy = "use Jira ticket prefix like PROJ-123, then kebab-case summary"

Delivery strategy? Same pattern:

[delivery]
mode = "pr"
target_strategy = "target develop for features, main for hotfixes"

Most of the configuration is "tell it what you want in plain English." Orc interprets it.

Token efficiency by design

Coordination happens through the filesystem, not agent-to-agent conversation. An engineer writes review to a .worker-status file. The orchestrator reads the file. Zero tokens burned on supervisors polling workers or nudging stalled agents.

The tools you already have (tmux for sessions, git worktrees for isolation, the filesystem for signals) solve most of the orchestration problem. The interesting part is the decomposition, dispatch, and review protocol on top.

YOLO mode

Sometimes you don't want to babysit.

orc myapp --yolo

All approval gates are skipped. Planning flows straight into dispatch. Agents launch with auto-accept flags.

But it still escalates on merge conflicts, blocked engineers, and out-of-scope discoveries. We're not animals.

Works with your agent

Claude Code, OpenCode, Codex, or bring your own. Personas are markdown files you can override per-project. Adding a new agent is a single adapter.

Credit where it's due

Huge respect to Gas Town for proving this category matters and pushing everyone's thinking forward. Orc asked "what's the minimum viable version of this?"

Try it

git clone https://github.com/spencermarx/orc.git
cd orc && pnpm install
pnpm orc:install
orc add myapp /path/to/your/project
orc myapp

Now go. Release the horde.

GitHub: spencermarx/orc

Star it if it's useful. PRs are welcome. Issues too.

Open Code Review changed AI-Assisted Dev for our team

Spencer Marx — Wed, 11 Mar 2026 14:55:40 +0000

Spencer Marx

Mar 11

Your AI code reviewer has no one to disagree with

#opensource #ai #codereview #claudecode

Comments 4

5 min read

Your AI code reviewer has no one to disagree with

Spencer Marx — Wed, 11 Mar 2026 14:48:03 +0000

Ask an AI to review your code and you get one model's opinion. One pass through the diff. Whatever it happens to focus on first.

Sometimes that's fine. Sometimes it catches real stuff.

But if you've ever been on a team with strong review culture you know that's not how the best reviews work. The best reviews happen when people with different concerns look at the same code and then argue about what they found.

The security person flags something. The architect says "actually that's fine because of how we structured X." The quality engineer notices they're both missing an error handling gap that connects the two findings. The conversation surfaces things no individual reviewer would have caught alone.

That back-and-forth is where the real signal lives. And every AI code review tool I've tried just... skips it entirely.

One pass is a coin flip with better marketing

Here's what bugs me about the current crop of AI review tools.

They're all doing fundamentally the same thing: take a diff, throw it at a model, format the output nicely. Some add project context. Some run multiple checks in parallel. But at the end of the day you're getting a single perspective, uncontested, with nobody pushing back on whether the findings are actually real.

You know what you get from an uncontested review? False positives. Hallucinated findings. Surface-level nitpicks dressed up as critical issues. And occasionally, actually useful feedback buried somewhere in the noise.

Sound familiar? It should. It's the same reason a single human reviewer isn't sufficient for important code either. We solved this decades ago with the concept of multiple reviewers. It just took us a while to apply the same logic to the AI versions.

What if the reviewers actually talked to each other?

This is the question that led to Open Code Review.

I started building it as an internal tool for our team because we were frustrated with exactly the problem above. The idea was stupid simple: what if we structured AI code review the same way high performing engineering teams actually do it?

So here's how it works:

You configure a team of reviewers with specific roles. Architecture, security, code quality, testing, whatever custom roles make sense for your codebase.
Each reviewer does their pass independently. Different concerns, different focus areas, different findings.
Then comes the part that actually matters: a structured discourse step where they debate each other's findings. Agree, challenge, connect related issues, surface new concerns.
Only then does a final synthesis produce the review you actually see.

                    ┌─────────────┐
                    │  Tech Lead  │  ← Orchestrates
                    └──────┬──────┘
                           │
         ┌─────────────────┼─────────────────┐
         ▼                 ▼                 ▼
   ┌───────────┐    ┌───────────┐    ┌───────────┐
   │Principal×2│    │ Quality×2 │    │ Security  │
   └───────────┘    └───────────┘    └───────────┘
         │                 │                 │
         └─────────────────┼─────────────────┘
                           ▼
                    ┌─────────────┐
                    │  Discourse  │  ← They argue
                    └──────┬──────┘
                           ▼
                    ┌─────────────┐
                    │  Synthesis  │  ← You get this
                    └─────────────┘

That discourse step is the entire point. Every finding gets pressure tested by reviewers with different perspectives before it reaches you. Hallucinated issues get challenged. Connected problems get linked. Blind spots get exposed.

The result is way fewer false positives and way more signal. Not because any individual reviewer is smarter, but because contested findings are just higher quality than uncontested ones. Same reason peer review works for humans.

Customizable to the moon (or just use the defaults)

Your codebase isn't generic and your review team shouldn't be either.

# .ocr/config.yaml
default_team:
  principal: 2    # Architecture, design
  quality: 2      # Code style, best practices
  security: 1     # Auth, data handling
  testing: 1      # Coverage, edge cases

Need heavier security scrutiny for a payments service? Bump it to 3. Building something performance-sensitive? Create a custom reviewer:

# .ocr/skills/references/reviewers/performance.md

# Performance Engineer

You are a performance-focused code reviewer. {ADD MORE HERE}

## Focus Areas
- Response times and latency
- Memory usage and leaks
- Database query efficiency
- N+1 queries, unbounded loops, missing indexes
- {ADD MORE HERE}

Build these from the dashboard, or drop that file in and tell OCR to use it, and now it participates in discourse alongside everyone else. It challenges the other reviewers and gets challenged right back.

Or don't think about any of this and just run it with the built-in templates. It works out of the box.

It knows about your requirements, not just "best practices"

This is the other thing that drives me nuts about most review tools. They evaluate your code against generic best practices and have no concept of what you were actually trying to build.

OCR lets you pass in a spec, a proposal, acceptance criteria from a ticket, whatever:

/ocr-review Review my staged changes against openspec/specs/cli/spec.md

Every reviewer evaluates the code against both their expertise and your stated requirements. The final synthesis includes a requirements verification showing what's met, what's got gaps, and what's ambiguous.

If you're doing any kind of spec-driven development this is where it really clicks. We were partly inspired by OpenSpec on this front.

Drops in, stays out of the way

I cannot stress enough how little this should disrupt your existing workflow. It was a core design goal.

npm install -g @open-code-review/cli
cd your-project
ocr init

It auto-detects whatever agentic environment you're using. Claude Code, Opencode, Cursor, Windsurf, GitHub Copilot, doesn't matter. Stage your changes, run /ocr-review, done. There's a local-first dashboard if you want to watch progress in real-time. You can post reviews directly to your PR with /ocr-post.

Two minutes to try. No SaaS. No per-seat pricing. Free and open source.

So is it actually better?

Our team hasn't gone back to anything else. The review quality just isn't close.

And I think that comes down to something really simple: an uncontested opinion is worth less than a contested one. It doesn't matter how smart the model is. If nothing pushes back on its findings before they reach you, you're going to spend your time filtering noise instead of acting on real issues.

Make the reviewers argue first. Get the noise out before it's your problem.

GitHub: github.com/spencermarx/open-code-review

If you try it out I'd love to hear how it goes. Still early days and the feedback has been shaping this thing significantly.

CRM Development: Unlocking Growth with Custom Solutions

Spencer Marx — Tue, 14 Jan 2025 15:05:02 +0000

Transform Your Business with Custom CRM Development 🚀

👉 Read the full blog post for detailed insights here.

Customer Relationship Management (CRM) systems are no longer just "nice-to-have" tools—they’re essential for businesses that want to grow, streamline operations, and keep customers coming back. But here’s the catch: generic CRMs can’t always meet your unique needs.

This is where custom CRM development comes in. Imagine a system built specifically for your workflows, seamlessly integrating with your existing tools, and adapting to your business as it scales. Sound good? Let’s break it down.

Why Custom CRM Development? 🤔

Tailored to Your Needs: From industry-specific workflows to advanced compliance (think HIPAA or GDPR), a custom CRM aligns perfectly with your business.
Streamlined Integrations: Whether it’s ERP, marketing tools, or accounting software, custom solutions connect your systems for seamless data sharing.
Scalable and Future-Ready: Grow your CRM alongside your business without the limitations of off-the-shelf tools.

What’s Inside a Great CRM? 🌟

Custom CRMs are built with the essentials and then some:

Workflow Automation: Say goodbye to manual tasks with automated reminders, lead scoring, and pipeline updates.
Advanced Reporting: Get real-time insights into customer behavior, sales performance, and marketing ROI.
User-Friendly Design: Intuitive dashboards and responsive layouts make adoption easy for your team.

Overcome CRM Challenges with Ease 💡

Unified Data: Stop juggling multiple tools. A custom CRM gives you a 360° view of each customer.
Enhanced Security: Meet industry compliance standards with role-based access and robust encryption.
High Adoption Rates: Custom CRMs are designed for your team’s exact needs, making them easier to use and love.

Ready to Take the Next Step? 👨‍💻👩‍💻

Whether you’re building a CRM from scratch or upgrading a legacy system, Aclarify’s custom CRM development services can guide you every step of the way.

💡 Explore the full blog post for an in-depth guide: Read it here.

📩 Want a custom CRM built for your business? Contact us today!

Let’s build something extraordinary together.

Unlocking the Power of the ServiceTitan API for Custom Integrations

Spencer Marx — Thu, 09 Jan 2025 09:44:25 +0000

Supercharge Your Operations with the ServiceTitan API 🚀

👉 Read the full blog post for in-depth guidance here.

Ever felt limited by your out-of-the-box software? With the ServiceTitan API, service-based businesses like HVAC, plumbing, and electrical companies can go beyond standard workflows. Imagine automating tasks, syncing data across platforms, and crafting custom tools that directly fit your needs. Intrigued? Let’s dive in.

Why Use the ServiceTitan API? 🤔

Here’s how this API can transform your operations:

Seamless Integrations: Connect ServiceTitan with CRMs, ERPs, or reporting tools like Salesforce and Power BI.
Task Automation: Eliminate manual data entry by triggering emails, Slack alerts, or CRM updates.
Custom Solutions: Build dashboards, tools, or client-facing apps tailored to your business.
Break Down Silos: Enable real-time data exchange, reducing errors and streamlining workflows.
Scalability: Expand your integrations as your business grows.

A Built-In Shortcut: Postman Starter Collection 💡

Getting started with the ServiceTitan API is easier than ever, thanks to our pre-configured Postman starter collection.

Here’s what’s included:

Environment Variables: Pre-set fields for tenant IDs, client secrets, and base URLs to simplify setup.
Pre-Request Script for Authentication: Automatically fetches OAuth tokens using your credentials. No manual copy-pasting required!
Sample Endpoints: Prebuilt requests for essential operations like fetching technicians, invoices, and customer details.

👉 Download the Postman Starter Collection here and jumpstart your integration testing today.

Get Started with the ServiceTitan API in 5 Steps

To begin your API journey, follow these steps:

Request API Access: Sign up via the ServiceTitan Developer Portal.
Set Up Your App: Define your app’s name, scope, and permissions in the portal.
Authorize in ServiceTitan: Connect your app in the ServiceTitan UI and generate credentials like Client ID and Client Secret.
Test with Postman: Import our starter collection and make your first authenticated request in minutes.
Build Your Integration: Start small—sync invoices or automate customer updates—then scale.

Real-World Use Cases 🌟

Here are just a few examples of what’s possible:

Two-Way Accounting Sync: Connect ServiceTitan with QuickBooks or Xero to automate invoices and payments.
Advanced Reporting: Export job data to Power BI or Tableau for deeper insights.
Inventory Management: Track stock levels and equipment life cycles across systems.
Automated Marketing: Trigger campaigns based on job completions or renewals.
IoT Integration: Sync real-time device data to your workflows.

The possibilities are endless with the ServiceTitan API.

Developers, Ready to Dive In? 👨‍💻👩‍💻

If you’re a developer eager to create meaningful integrations or a service business looking for custom solutions, Aclarify can help.

💡 Explore the full blog post for step-by-step guidance: Read it here.

📩 Curious about how we can help? Contact us today!

Let’s build something extraordinary together.

What is Nearshore Software Development and Why Does It Matter?

Spencer Marx — Thu, 09 Jan 2025 09:17:05 +0000

Nearshore Software Development: Where Talent Meets Collaboration 🚀

Imagine collaborating with skilled developers who work in nearly the same time zone, share your work culture, and deliver exceptional results—all without skyrocketing costs. Welcome to nearshore software development, a model that’s transforming how modern businesses scale their tech teams.

At Aclarify, we’ve perfected this approach. With offices in the US and Spain and teams across Italy, Argentina, Ukraine, West Africa, we bridge global talent with seamless workflows to help companies thrive. Curious about how we make it work? Keep reading—or dive deeper in our blog post for a complete guide. 🌍

Why Nearshore Development? 🌟

Time Zone Alignment: Forget the long delays of offshore teams. Nearshore developers work just hours apart, making real-time collaboration a breeze.
Cultural Fit: Similar work ethics and shared values ensure smooth communication and strong team dynamics.
Cost Savings: Nearshore rates strike a perfect balance—more affordable than onshore and without the challenges of offshore.
Scalable Talent: Expand your team quickly with vetted engineers who integrate seamlessly into your workflows.

What Sets Nearshore Apart? 🤔

Factor	Onshore	Nearshore	Offshore
Location	Same country	Nearby country	Different continent
Cost	$$$$	$$-$$$	$
Time Zone Overlap	Full	High/Partial	Minimal
Cultural Alignment	Strong	Moderate to High	Low

Nearshoring combines the best of both worlds—agility and cultural alignment without the high costs of onshore or the barriers of offshore.

Developers, This One's For You 👩‍💻👨‍💻

Looking to join a dynamic, distributed team that collaborates across continents? At Aclarify, we’re always on the lookout for talented developers passionate about solving complex challenges and creating cutting-edge solutions. Our global presence means you’ll work with diverse teams, gain unique perspectives, and have the chance to make a real impact.

💡 Discover what it’s like to work at Aclarify and meet our team: Learn more here.

📩 Interested in joining us? Contact us directly to explore career opportunities.

Ready to Dive Deeper? 🔗

For an in-depth exploration of nearshore software development, its benefits, and how to choose the right partner, check out our full blog post:

➡️ Read the Full Blog Here.

🌟 Curious about career opportunities? Get in touch today!

We’d love to connect and create something extraordinary together.

Wrestling with Google Tag Manager (GTM) and Consent Mode in a Next.js project? We've got you covered 💪

Spencer Marx — Thu, 05 Dec 2024 15:33:50 +0000

Integrating Google Tag Manager with Consent Mode in NextJS 15

Spencer Marx ・ Dec 5 '24

#nextjs #react #googletagmanager #consentmode

Integrating Google Tag Manager with Consent Mode in NextJS 15

Spencer Marx — Thu, 05 Dec 2024 13:53:01 +0000

Simplifying Analytics and Privacy Compliance in NextJS 15

For modern developers, integrating Google Tag Manager (GTM) and Consent Mode into NextJS 15 apps isn’t just a best practice—it’s a necessity. But the reality? It’s far from straightforward.

Privacy regulations like GDPR and CCPA require careful handling of consent states, while NextJS 15’s limitations add layers of complexity to embedding GTM scripts dynamically. The result? Many developers struggle to implement compliant analytics systems without compromising user experience or functionality.

Why This Guide?

This tutorial was built with one goal: to address the most common and frustrating challenges developers face when integrating GTM and Consent Mode into NextJS 15 projects.

Here’s what makes this guide different:

NextJS’s Limitations: Tools like @next/third-parties don’t offer robust support for Consent Mode. Specifically, they lack solutions for managing default consent states before loading cached consent values—a critical gap we solve in this guide.
Documentation Gaps: The official guides and third-party libraries provide fragmented examples, often failing to address how to fully integrate GTM, Consent Mode, and cookie banners into a seamless, scalable NextJS app.
A Proven, Hands-On Approach: This isn’t theoretical. The solutions we present are battle-tested, combining best practices with extended functionality to ensure both analytics precision and privacy compliance.

What You’ll Gain

Step-by-Step Implementation: Learn how to integrate GTM scripts, manage dynamic consent states, and set up analytics in a privacy-first web environment.
TypeScript-First Utilities: Build reusable, strongly-typed functions to track user events and manage cookie preferences.
Working Example Repository: Clone our project to see the complete implementation in action. Compare your work at each step, ensuring your setup aligns with best practices.

Access the Codebase

Start with the initial boilerplate and follow the phased approach detailed in the guide. Each branch demonstrates a critical step in the integration process.

# Clone the Repository
git clone https://github.com/spencermarx/aclarify-blog-example--gtm-with-consent-in-nextjs.git

# Navigate to the Project Directory
cd aclarify-blog-example--gtm-with-consent-in-nextjs

# Checkout the First Phase
git checkout phase/0-initial-boilerplate

# Install Dependencies and Run
npm install
npm run dev

With this repo, you’ll have a reliable reference point for every phase of the implementation.

Why Read This Guide?

By the end of this tutorial, you’ll:

Master the complexities of embedding GTM scripts dynamically in NextJS 15 without performance trade-offs.
Implement a cookie consent banner to handle privacy-first tracking and comply with regulations like GDPR and CCPA.
Gain confidence in testing and debugging with tools like Google Tag Assistant.
Build a robust, scalable solution for managing analytics in modern NextJS projects.

Ready to tackle analytics integration while keeping privacy compliance in check?

➡️ Read the Full Guide and Explore the Repository on Aclarify’s Blog here ⬅️

About Aclarify: We empower developers to build modern, privacy-compliant solutions with cutting-edge tools like NextJS, Google Tag Manager, and Consent Mode. Join us to streamline your development process and achieve your goals.

Build a Seamless ServiceTitan Integration with Next.js: A Modern, Full-Stack Guide

Spencer Marx — Mon, 28 Oct 2024 20:40:00 +0000

Supercharge Your Service Business with a Custom ServiceTitan Integration

In the service industry—covering essential businesses like HVAC, plumbing, electrical services, and beyond—streamlined operations are key to profitability. But for companies using ServiceTitan, one of the most popular platforms for managing scheduling, dispatch, and customer communication, there's a common roadblock: the API documentation and examples are, well, limited. (Queue sad face 😢)

If you're trying to build custom solutions, you may find yourself hunting for real-world examples or best practices to get started.

That’s where Aclarify comes in.

Our latest blog post dives into a comprehensive, step-by-step guide to building a custom integration between ServiceTitan and a modern Next.js application. And this isn’t just another tutorial—it’s packed with practical insights, code examples, and solutions to common challenges that aren’t covered anywhere else.

What’s Inside?

Demo Repository: Access a fully built-out repository with a modern Next.js setup and pre-built ServiceTitan integration components. Perfect for exploring, modifying, and understanding best practices in a hands-on way.
Full-Stack Type Safety: Learn how to manage full-stack typing with TypeScript for a ServiceTitan API endpoint, ensuring your data flow is both reliable and maintainable across the backend and frontend.
Real-World Examples: From handling ServiceTitan API authentication to implementing booking forms with custom workflows, this guide is packed with code snippets and solutions you can actually use.
Enterprise-Grade Practices: The architecture and stack choices in this guide reflect standards seen at enterprise companies—TypeScript, Tailwind CSS, React hooks, server actions in Next.js, and secure API handling.

Why This Guide is a Must-Read

This is one of the only comprehensive resources out there for developers and technical teams who need to work with ServiceTitan. Unlike typical guides, it’s designed to help you:

Save time by avoiding common pitfalls in ServiceTitan’s API.
Go beyond the basics, with a highly modular and scalable architecture.
Gain insights on integrating with ServiceTitan’s complex API, which doesn’t have extensive documentation for developers.

By the end of the tutorial, you’ll not only have a working integration—you’ll have a blueprint for building future-proof, customized solutions that streamline operations and delight your customers.

Read the full guide on Aclarify's website and access the demo repo, code samples, and more.

About Aclarify: We specialize in developing custom software solutions that transform service-based businesses. From field service operations to customer engagement, our technology-driven approach helps companies achieve seamless, modern workflows.