DEV Community: kathan

Stop Wasting Money, Free AI API Alternatives Explained

kathan — Mon, 11 May 2026 09:36:23 +0000

Every developer knows this moment.

You have a feature idea. Something genuinely useful AI-generated descriptions, smart categorisation, a natural language search. You open the OpenAI docs, get to the billing page, and quietly close the tab.

It happens more than anyone admits. The friction of setting up paid API access kills more prototypes than bad ideas ever do.

Here's what I found out the hard way: Google has been giving away free Gemini API access this whole time.

No credit card. No 30-day trial. No expiry countdown. Just a real API key connected to real production-grade models.

What You Actually Get for Free

This is the part that surprised me. The free tier isn't some stripped-down preview model you get access to:

Gemini 2.5 Flash — 10 RPM, 250 requests/day, 1M token context
Gemini 2.5 Flash-Lite — 15 RPM, 1,000 requests/day (highest free daily volume)
Gemini 2.5 Pro — 5 RPM, 100 requests/day (the full reasoning model, free)
Gemini 3 Flash & 3.1 Flash-Lite — preview access, more restrictive limits

All of them share a 1 million token context window and 250,000 TPM. At zero cost.

I Used It on a Real Client Project

Not a toy project. I wired the free Gemini 2.5 Flash into a Next.js API route to validate an AI feature for a furniture manufacturing client before committing any budget. The whole test took 20 minutes, cost $0, and gave me enough confidence to recommend the feature for the paid roadmap.

The code was literally:

const GEMINI_URL = `https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent?key=${GEMINI_API_KEY}`;

That's the entire integration surface. One URL. One API key from Google AI Studio. Done.

There's More to Know Before You Use It

The free tier has some important nuances rate limits that caught developers off guard in late 2025, which models are not available for free (Gemini 3.x Pro is paid-only), the data privacy clause you need to read if you're building for clients, and the exact 7-step process to get your API key without setting up Google Cloud billing.

I wrote up the full breakdown advantages, IT use cases, enrollment steps, all free model limits, and the real client example with complete code on my blog:

👉 Read the full guide on kathanpatel.vercel.app

If you've been putting off AI integration because of cost this removes that excuse entirely.

Hello, I'm Kathan a freelance .NET dev. If this helped, check out my website — I'm available for contract work.

Building an Interactive Cohort Analysis Chart in WPF and What Happens When You Ask AI to Do It Instead

kathan — Tue, 05 May 2026 11:00:57 +0000

Cohort analysis is a staple of financial and product analytics you group data by time period and track how each cohort behaves across subsequent periods. The visualization is a matrix: cohorts on the rows, time offsets on the columns, values in the cells. Sounds simple. The implementation is anything but, especially when you add interactivity.

I built this cohort analysis chart for financial trading analytics — a 13×14 interactive matrix with keyboard navigation, live timer cells, row/column highlighting on selection, and a detailed buy/sell order popup. Then, as an experiment, I asked AI to generate the same component from scratch. The results revealed something important about where AI-assisted development genuinely helps and where domain knowledge is irreplaceable. The full source is on GitHub.

The Component Requirements
Before writing any code, the requirements for this chart were specific:

A 13×14 matrix grid where each cell represents a cohort/period intersection
Mouse click to select a cell — highlights the entire row and column headers
Keyboard navigation with Arrow keys to move between cells
Enter key to open a detailed popup for the selected cell
Some cells contain live updating timer values (countdown/elapsed)
The popup shows buy/sell order details for the selected cohort intersection
Clean MVVM architecture so the UI and data are properly separated
Smooth visual feedback — selected state, hover state, header highlighting

Every one of these requirements interacts with the others in non-obvious ways. The keyboard navigation has to know which cell is selected. The header highlighting has to respond to the same selection. The popup has to receive the right data context. This is the category of UI component where getting the architecture right upfront saves days of rework.

The Data Model — Start with the Cell
Every cell in the matrix is a MatrixElement — a model that holds the cell's data, its position in the grid, its display state, and whether it contains a live timer. Getting this model right is the foundation everything else builds on.

// MatrixElement.cs — the fundamental cell model
public class MatrixElement : INotifyPropertyChanged
{
    private bool   _isSelected;
    private bool   _isRowHighlighted;
    private bool   _isColumnHighlighted;
    private string _displayValue = string.Empty;
    private bool   _isTimerCell;
    private TimeSpan _elapsed;

    public int    Row     { get; set; }
    public int    Column  { get; set; }
    public string Label   { get; set; } = string.Empty;
    public CellType Type  { get; set; }   // Header | Data | Timer | Empty

    public bool IsSelected
    {
        get => _isSelected;
        set { _isSelected = value; OnPropertyChanged(); }
    }

    public bool IsRowHighlighted
    {
        get => _isRowHighlighted;
        set { _isRowHighlighted = value; OnPropertyChanged(); }
    }

    public bool IsColumnHighlighted
    {
        get => _isColumnHighlighted;
        set { _isColumnHighlighted = value; OnPropertyChanged(); }
    }

    public string DisplayValue
    {
        get => _displayValue;
        set { _displayValue = value; OnPropertyChanged(); }
    }

    public bool IsTimerCell
    {
        get => _isTimerCell;
        set { _isTimerCell = value; OnPropertyChanged(); }
    }

    // For live timer cells — updated by a DispatcherTimer
    public TimeSpan Elapsed
    {
        get => _elapsed;
        set
        {
            _elapsed = value;
            // Auto-update display value when timer ticks
            if (IsTimerCell)
                DisplayValue = value.ToString(@"mm\:ss");
            OnPropertyChanged();
        }
    }

    public event PropertyChangedEventHandler? PropertyChanged;
    protected void OnPropertyChanged([CallerMemberName] string? name = null)
        => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
}

Building the Matrix Grid in XAML
The matrix uses an ItemsControl with a UniformGrid as its items panel. This gives us automatic, even cell sizing without manually calculating widths and heights. The data template for each cell uses a MultiBinding to drive the background color from three independent states: selected, row-highlighted, and column-highlighted.

<!-- the cohort matrix -->
<ItemsControl x:Name="CohortMatrix"
              ItemsSource="{Binding MatrixElements}"
              KeyDown="Matrix_KeyDown"
              Focusable="True">

    <ItemsControl.ItemsPanel>
        <ItemsPanelTemplate>
            <!-- 14 columns: 1 row header + 13 period columns -->
            <UniformGrid Columns="14" />
        </ItemsPanelTemplate>
    </ItemsControl.ItemsPanel>

    <ItemsControl.ItemTemplate>
        <DataTemplate DataType="{x:Type local:MatrixElement}">
            <Border x:Name="CellBorder"
                    BorderBrush="#333"
                    BorderThickness="0.5"
                    Cursor="Hand"
                    MinWidth="80"
                    MinHeight="40"
                    MouseLeftButtonDown="Cell_MouseLeftButtonDown"
                    MouseDoubleClick="Cell_MouseDoubleClick">

                <Border.Background>
                    <!-- Priority: Selected > Column highlighted > Row highlighted > Default -->
                    <MultiBinding Converter="{StaticResource CellBackgroundConverter}">
                        <Binding Path="IsSelected" />
                        <Binding Path="IsRowHighlighted" />
                        <Binding Path="IsColumnHighlighted" />
                        <Binding Path="Type" />
                    </MultiBinding>
                </Border.Background>

                <Grid>
                    <TextBlock Text="{Binding DisplayValue}"
                               HorizontalAlignment="Center"
                               VerticalAlignment="Center"
                               FontSize="12"
                               Foreground="{Binding IsSelected,
                                   Converter={StaticResource SelectedForegroundConverter}}" />
                </Grid>
            </Border>
        </DataTemplate>
    </ItemsControl.ItemTemplate>
</ItemsControl>

The Selection Logic — Highlighting Rows and Columns
When a cell is selected, the entire row and column need to visually indicate which headers correspond to that cell. This is the interaction that makes cohort analysis readable — you always know which cohort (row) and which time period (column) you are looking at. The logic clears all previous highlights, then applies the new ones in a single pass.

// xaml.cs — selection and highlight logic
private MatrixElement? _selectedElement;

private void SelectCell(MatrixElement cell)
{
    if (cell.Type == CellType.Header || cell.Type == CellType.Empty)
        return;

    // Clear previous selection state
    foreach (var el in MatrixElements)
    {
        el.IsSelected         = false;
        el.IsRowHighlighted   = false;
        el.IsColumnHighlighted = false;
    }

    _selectedElement = cell;
    cell.IsSelected = true;

    // Highlight all cells in the same row
    foreach (var el in MatrixElements.Where(e => e.Row == cell.Row))
        el.IsRowHighlighted = true;

    // Highlight all cells in the same column
    foreach (var el in MatrixElements.Where(e => e.Column == cell.Column))
        el.IsColumnHighlighted = true;
}

// Keyboard navigation — Arrow keys move selection
private void Matrix_KeyDown(object sender, KeyEventArgs e)
{
    if (_selectedElement is null) return;

    int currentRow = _selectedElement.Row;
    int currentCol = _selectedElement.Column;

    var (targetRow, targetCol) = e.Key switch
    {
        Key.Up    => (currentRow - 1, currentCol),
        Key.Down  => (currentRow + 1, currentCol),
        Key.Left  => (currentRow, currentCol - 1),
        Key.Right => (currentRow, currentCol + 1),
        _         => (currentRow, currentCol)
    };

    var target = MatrixElements
        .FirstOrDefault(el =>
            el.Row    == targetRow &&
            el.Column == targetCol &&
            el.Type   == CellType.Data);

    if (target is not null)
    {
        SelectCell(target);
        e.Handled = true;  // Prevent default scroll behaviour
    }

    if (e.Key == Key.Enter && _selectedElement is not null)
        OpenDetailPopup(_selectedElement);
}

Live Timer Cells — Real-Time Updates Without Freezing the UI
Some cells in the matrix show live elapsed time — they count up or down in real time. The challenge is updating these cells frequently without causing the entire 13×14 grid to re-render on every tick. The solution is a DispatcherTimer that only updates the specific timer cell models, not the full collection.

private readonly DispatcherTimer _liveTimer;
private readonly List<MatrixElement> _timerCells = [];

private void InitialiseLiveTimers()
{
    // Identify which cells have live timers
    // (e.g. cells in the most recent cohort column)
    _timerCells.AddRange(
        MatrixElements.Where(el => el.IsTimerCell));

    _liveTimer = new DispatcherTimer
    {
        Interval = TimeSpan.FromSeconds(1)
    };

    _liveTimer.Tick += (_, _) =>
    {
        foreach (var cell in _timerCells)
        {
            // Increment elapsed — the property setter auto-updates DisplayValue
            cell.Elapsed = cell.Elapsed.Add(TimeSpan.FromSeconds(1));
        }
        // Only timer cells fire PropertyChanged — the rest of the grid is untouched
    };

    _liveTimer.Start();
}

The Detail Popup — Context-Aware Order View
Double-clicking a cell or pressing Enter opens a popup showing the buy/sell order details for that cohort intersection. The popup receives the selected MatrixElement as its data context and shows the associated Order objects — bid price, ask price, quantity, and time.

// Order.cs — the detail model shown in the popup
public class Order
{
    public string  OrderId    { get; set; } = string.Empty;
    public decimal BidPrice   { get; set; }
    public decimal AskPrice   { get; set; }
    public int     Quantity   { get; set; }
    public string  Side       { get; set; } = "Buy"; // Buy | Sell
    public DateTime Timestamp { get; set; }
    public string  Status     { get; set; } = "Open";

    public decimal Spread => AskPrice - BidPrice;
    public string  DisplayTime => Timestamp.ToString("HH:mm:ss");
}

// Open popup with correct context
private void OpenDetailPopup(MatrixElement cell)
{
    var orders = GetOrdersForCell(cell); // Load from data source

    var popup = new OrderDetailWindow
    {
        DataContext = new OrderDetailViewModel
        {
            Cell          = cell,
            Orders        = new ObservableCollection<Order>(orders),
            CohortLabel   = GetRowLabel(cell.Row),
            PeriodLabel   = GetColumnLabel(cell.Column),
        },
        Owner = this,
        WindowStartupLocation = WindowStartupLocation.CenterOwner
    };

    popup.ShowDialog();
}

What Happened When I Asked AI to Build This
This is where it gets interesting. After building the component manually, I described the same requirements to an AI assistant and asked it to generate the WPF cohort chart. The AI produced code quickly. But here is what it got wrong — and why each problem required domain knowledge to catch.

Problem 1: The selection model was wrong. AI generated a SelectedItem binding on the ItemsControl — but ItemsControl does not have selection built in. Only ListBox does. The AI confused two different WPF controls with similar purposes. The result compiled, but clicking a cell did nothing. A developer knows the distinction; a non-developer would stare at a working build that does not respond to clicks.

Problem 2: Row/column highlighting used a value converter that re-evaluated the entire grid. AI's approach to highlighting involved a converter that checked the selected row and column index against every cell on every property change. With 182 cells and a selected cell changing on every keystroke, this triggered 182 converter evaluations on every arrow key press. On a modern machine it was imperceptible. On the target trading workstation with multiple charts running simultaneously, it caused noticeable lag. The solution — keeping IsRowHighlighted and IsColumnHighlighted as direct properties on each cell — was more code but dramatically better for performance.

Problem 3: The timer cells caused the entire grid to re-render every second. AI's timer implementation raised PropertyChanged on the collection itself rather than on the individual cell models. Every tick caused all 182 cells to re-evaluate their bindings. At 1-second intervals this was visually fine, but at the 100ms update rate some financial matrices need, it produced visible flicker across the entire grid. The fix targeted property change notifications only on timer cells required understanding how WPF's binding engine decides what to re-render.

The Pattern: AI Knows the How, Not the Why
After building the cohort chart both manually and with AI assistance, the pattern is consistent with everything I have seen on larger projects. AI knows how to write WPF code — the syntax, the patterns, the common approaches. It does not know why one approach performs better than another in a specific context, or why ItemsControl and ListBox look similar but behave fundamentally differently for selection scenarios.

For a data visualisation component used in financial trading where performance matters and incorrect data display has real consequences that distinction is the entire job. The AI gives you a working prototype in minutes. Making it production-ready is still the developer's work.

Hello, I'm Kathan a freelance .NET dev. If this helped, check out my website — I'm available for contract work.

I Built a Full-Stack E-Commerce Website Entirely with AI. Here's What Actually Happened

kathan — Mon, 04 May 2026 11:22:41 +0000

Everyone is talking about AI replacing developers. I wanted to test that claim with a real project — not a tutorial, not a todo app, but a production-grade full-stack application with real business requirements. The result is Craftura Fine Furniture: a complete furniture manufacturing website with B2B and B2C ordering, an admin panel, analytics dashboard, CMS, SEO, dark/light mode, email notifications, and WhatsApp integration. Built with Next.js 14, Prisma ORM, and SQLite.

This is the honest account of that experience. What AI built brilliantly. Where it fell short. The bugs it introduced that only a developer could catch. And the final cost comparison that will surprise you.

The Project Scope — What Was Actually Built
Before evaluating AI's contribution, it is worth being specific about what Craftura actually contains. This was not a simple storefront. The final application has:

Customer-facing: Product browsing with search and category filters, product detail pages with image galleries, an inquiry cart (multi-item, B2B-style), order tracking with animated status progression, order self-cancellation, a project gallery with masonry layout and lightbox, a bulk orders page for B2B quote requests, WhatsApp integration on every key action, and dark/light mode persisted across sessions.

Admin panel: Analytics dashboard with charts (bar, donut, trend line), manufacturing cost report, repeat customer detection, revenue forecast widget, data export to CSV and Excel, product CRUD with drag-and-drop image upload, category management, order status management, inquiry management, gallery management, and a CMS for editing site content and toggling navigation items on and off.

Technical: 9 Prisma database models, JWT authentication with middleware route protection, Nodemailer email notifications, dynamic sitemap.xml, robots.txt, JSON-LD structured data, per-page Open Graph metadata, and PostgreSQL-ready schema migration in 2 line changes.

That is a serious amount of software. Let me tell you how AI contributed to building it.

How AI Actually Helps — The Real Workflow
The workflow was not "tell AI what to build and deploy what it gives you." That is a fantasy. The real workflow was iterative — describe a requirement, review the output, test it, identify what was wrong, correct it, and move on. Think of AI as an extremely fast junior developer who writes code instantly but needs careful supervision.

Where AI genuinely accelerated development:

Boilerplate and structure — setting up the Next.js 14 App Router structure, configuring Prisma with the initial schema, wiring up Tailwind CSS, creating the base layout components. Work that would have taken half a day manually was done in minutes.

Repetitive CRUD operations — once the pattern for one API route was established (say, products), AI generated the equivalent for categories, orders, inquiries, and gallery items in seconds. Clean, consistent, following the same patterns.

Boilerplate-heavy features — the email notification templates, the WhatsApp link builder, the JWT auth utilities, the Prisma client singleton — all of these are well-understood patterns that AI executes reliably.

// Example: AI generated this Prisma schema from a plain description
// "I need products with multiple images, categories, B2B/B2C ordering,
// and a gallery with featured items"

model Product {
  id          String         @id @default(cuid())
  name        String
  slug        String         @unique
  description String?
  price       Float?
  minOrderQty Int            @default(1)
  isFeatured  Boolean        @default(false)
  isActive    Boolean        @default(true)
  categoryId  String
  category    Category       @relation(fields: [categoryId], references: [id])
  images      ProductImage[]
  orderItems  OrderItem[]
  createdAt   DateTime       @default(now())
  updatedAt   DateTime       @updatedAt
}

model Order {
  id           String      @id @default(cuid())
  orderNumber  String      @unique
  customerName String
  email        String
  phone        String?
  orderType    String      @default("B2C") // B2C | B2B
  status       String      @default("PENDING")
  // PENDING → CONFIRMED → IN_PRODUCTION → DELIVERED | CANCELLED
  totalAmount  Float?
  notes        String?
  items        OrderItem[]
  createdAt    DateTime    @default(now())
  updatedAt    DateTime    @updatedAt
}

// AI generated all 9 models correctly from plain English descriptions
// This saved approximately 2-3 hours of schema design

What AI Got Wrong — The Bugs Only a Developer Catches
This is the section most AI enthusiasm articles skip. AI makes mistakes. On Craftura, here are the real issues that appeared — and why non-technical users would never have caught them.

Bug 1: The Middleware Import That Broke Everything
AI generated the admin route protection middleware by importing a server-side utility (the JWT verification function) that internally uses next/headers. Next.js 14 middleware runs in the Edge Runtime — it cannot import Node.js APIs or anything that chains into them. The result was a cryptic runtime error that had nothing to do with authentication logic and everything to do with the execution environment.

// WRONG — what AI initially generated
// This crashes because verifyToken uses next/headers internally
import { verifyToken } from '@/lib/auth' // ← chains into next/headers

export async function middleware(request: NextRequest) {
  const token = request.cookies.get('admin-token')?.value
  const user  = await verifyToken(token) // ← crashes in Edge Runtime
  if (!user) return NextResponse.redirect(new URL('/admin/login', request.url))
}

// CORRECT — after identifying and fixing the issue
// Manually decode JWT in middleware without importing server utilities
import { jwtVerify } from 'jose'

export async function middleware(request: NextRequest) {
  const token  = request.cookies.get('admin-token')?.value
  if (!token) return NextResponse.redirect(new URL('/admin/login', request.url))

  try {
    const secret = new TextEncoder().encode(process.env.JWT_SECRET)
    await jwtVerify(token, secret)
    return NextResponse.next()
  } catch {
    return NextResponse.redirect(new URL('/admin/login', request.url))
  }
}

// This fix required understanding Next.js Edge Runtime constraints
// A non-developer would have no idea why the original code failed

Bug 2: The Infinite Redirect Loop
The middleware AI generated also caused an infinite redirect loop because it matched too broadly — intercepting even the login page itself and redirecting unauthenticated users to login, which then matched again, which redirected again. A browser hard refresh would spin forever. The fix required understanding how Next.js middleware matchers work and explicitly excluding the login route from protection.

// WRONG — matches /admin/login too, causes infinite redirect loop
export const config = {
  matcher: ['/admin/:path*']
}

// CORRECT — explicitly exclude the login page
export const config = {
  matcher: [
    '/admin/:path*',
    '/((?!admin/login|api/auth|_next/static|_next/image|favicon.ico).*)'
  ]
}

// Or more precisely — protect specific admin paths only:
export const config = {
  matcher: [
    '/admin',
    '/admin/analytics/:path*',
    '/admin/products/:path*',
    '/admin/orders/:path*',
    '/admin/categories/:path*',
    '/admin/inquiries/:path*',
    '/admin/gallery/:path*',
    '/admin/content/:path*',
  ]
}

Bug 3: The Analytics Charts Without a Library
The analytics dashboard required charts — bar charts for order volume over time, a donut chart for B2B/B2C split, a trend line for revenue. AI's first attempt imported Chart.js. When asked to build without any external library (to avoid bundle size overhead), it generated pure SVG charts. These looked correct but had a calculation error in the SVG coordinate mapping that caused bars to render at wrong heights when values were not evenly distributed. Finding this required reading the SVG path math and understanding how SVG viewBox coordinates work — not something a non-developer would spot visually until a client pointed out that the chart showed wrong numbers.

The Accuracy Question — What Can You Trust?
After building Craftura, my honest assessment of AI accuracy breaks down into three tiers:

High accuracy (trust but verify):
Database schema design, API route structure, Prisma queries, Tailwind CSS styling, TypeScript type definitions, email templates, environment variable setup. AI handles these reliably. Review them but expect them to work.

Medium accuracy (always test thoroughly):
Authentication flows, form validation, client-side state management, Next.js App Router patterns. AI gets these mostly right but introduces subtle issues — especially around Next.js-specific constraints like Edge Runtime, server vs client components, and caching behaviour. Always test end-to-end.

Lower accuracy (expect to rewrite):
Complex business logic, data visualisation calculations, performance optimisation, security hardening. AI gives you a starting point but the logic will often have edge cases or calculation errors. Plan to spend real development time on these.

The Cost Comparison — What This Would Have Cost
Let me be specific. Craftura has approximately 50+ files of production TypeScript code across the app, components, lib, prisma, and API directories. This includes 17+ pages, 20+ API routes, 9 database models, and a full admin panel.

Estimated development time breakdown:

Without AI assistance (senior developer estimate):
Database schema + Prisma setup: 1 day
Customer-facing pages (8 pages): 4–5 days
Admin panel (10 pages): 5–6 days
API routes (20+ endpoints): 3–4 days
Authentication + middleware: 1 day
Email + WhatsApp integration: 1 day
SEO + metadata + JSON-LD: 1 day
Analytics dashboard with charts: 2–3 days
Testing + debugging: 3–4 days
Total: approximately 21–26 days

With AI assistance (what actually happened):
AI generation + review + iteration: approximately 8–10 days

Time saved: roughly 60–65%

At a senior developer rate of $55–70/hr, 15 saved days represents $6,600–$8,400 in development cost. The AI subscription cost for the same period: under $50.

Why Technical Knowledge is Still Non-Negotiable
This is the part I want to be honest about — because the "anyone can build anything with AI" narrative is genuinely misleading and setting people up for problems.

On Craftura alone, catching and fixing the real issues required knowing:

Next.js Edge Runtime constraints — understanding that middleware cannot use Node.js APIs and why, then knowing how to use jose instead of a custom JWT utility
HTTP security principles — recognising that the default admin password and JWT secret should never appear in a public repository, even in example files
Database design — reviewing the generated Prisma schema and understanding whether the relationships, indexes, and cascade rules were appropriate for the actual access patterns
SVG coordinate systems — reading the chart math and identifying where the viewBox calculation was wrong
Next.js caching behaviour — knowing when to add revalidate or cache: 'no-store' to API calls that return real-time data like order statuses

None of these are things a non-developer would know to look for. AI would have happily shipped all of them. The middleware bug in particular would have meant the admin panel appeared to work but was not actually protected — any path traversal would have exposed the admin to unauthenticated access.

The Right Mental Model for AI-Assisted Development
After building Craftura, here is how I think about AI as a development tool:

AI is a force multiplier, not a replacement. A senior developer with AI assistance can do the work of 2–3 developers. A non-developer with AI assistance will produce code that appears to work but contains security vulnerabilities, logic errors, and architectural problems that they cannot identify.

The value is in the review, not the generation. Anyone can generate code with AI. The skill is knowing what to ask for, reading what comes back, identifying what is wrong, and knowing how to fix it. That skill requires the same technical foundation it always did.

AI accelerates the known, not the unknown. For established patterns — CRUD APIs, authentication, form handling, database queries — AI is extraordinarily fast and accurate. For novel problems, complex business logic, or framework-specific edge cases, AI is a starting point that needs significant developer input.

The cost saving is real, but so is the responsibility. Craftura was built significantly faster and cheaper with AI. But it was also built correctly because a developer reviewed everything. The cost saving disappears rapidly if you have to fix production bugs that a code review would have caught.

What I Would Do Differently
If I were to build Craftura again with AI assistance, I would change three things:

Define the architecture first, then generate. I would write a complete technical specification — database schema, API contract, component hierarchy — before generating any code. AI follows a good spec precisely. Asking it to figure out the architecture as it goes produces inconsistencies.
Generate one module at a time and test before proceeding. I would not generate the full admin panel and then start testing. I would generate one route, test it completely, then generate the next. Bugs compound when you generate everything first and test later.
Keep a context file for long sessions. I actually did this for Craftura — the .ai/ folder in the repository contains session context files that I gave to the AI at the start of each development session so it had the full architecture, schema, and patterns in context. This was one of the biggest productivity improvements — the AI produced consistent, pattern-following code because it knew the existing codebase.

Hello, I'm Kathan a freelance .NET dev. If this helped, check out my website — I'm available for contract work.

Extracting Structured Data from Images Using AI: Why GPT-4o Beats Traditional OCR for Real-World Documents

kathan — Fri, 01 May 2026 11:42:34 +0000

I've built traditional OCR pipelines using LEAD Tools, Tesseract, and ABBYY. They work — until they don't. A slightly rotated scan, a different font weight, a handwritten field in the margin, or a table with merged cells, and the accuracy collapses. You end up with brittle regex patterns, endless exception handling, and a maintenance burden that grows with every new document format the client sends.

Then I started using AI vision models for document extraction. The difference is significant enough that I've replaced traditional OCR with AI-based extraction on every new project since. This post explains the approach, shows the C# implementation, and covers when it works best and where to be careful.

Why Traditional OCR Fails on Real-World Documents
Traditional OCR engines convert image pixels to text. They do this well when documents are clean, consistently formatted, and machine-printed. Real-world documents are none of these things:

Invoices come from hundreds of different vendors with different layouts, fonts, and field positions.
Legal documents have handwritten annotations, stamps, and signatures that break character recognition.
Medical forms mix printed and handwritten content in the same field.
Scanned contracts are often skewed, noisy, or have watermarks.

Writing code to handle all of this — column detection, bounding box logic, field mapping, layout parsing — is a significant engineering effort. And every new document type breaks something.

The AI Approach: Describe What You Want, Get It
Modern vision models like GPT-4o from OpenAI (available through Azure OpenAI) understand document context the same way a human does. You send an image and a prompt describing exactly what data you want extracted and in what format. The model reads the document, understands its structure, and returns the data.

No layout parsing. No bounding boxes. No regex. No column detection. Just a prompt and a JSON response.

Real Example: Extracting Invoice Data
Let's say you receive vendor invoices as scanned PDFs or photos. You need to extract: invoice number, vendor name, invoice date, due date, line items (description, quantity, unit price, total), subtotal, tax, and grand total. Here's the complete implementation in C# using Azure OpenAI.

Step 1: Set Up Azure OpenAI Client

// Install: dotnet add package Azure.AI.OpenAI
// Install: dotnet add package Microsoft.Extensions.AI

// appsettings.json
{
  "AzureOpenAI": {
    "Endpoint": "https://your-resource.openai.azure.com/",
    "ApiKey":   "your-api-key",
    "Model":    "gpt-4o"
  }
}

// Program.cs
builder.Services.AddSingleton(sp =>
{
    var config   = sp.GetRequiredService<IConfiguration>();
    var endpoint = new Uri(config["AzureOpenAI:Endpoint"]!);
    var cred     = new AzureKeyCredential(config["AzureOpenAI:ApiKey"]!);
    return new AzureOpenAIClient(endpoint, cred);
});

builder.Services.AddScoped<IDocumentExtractionService, DocumentExtractionService>();

Step 2: Define Your Output Model
The key to reliable extraction is telling the AI exactly what JSON structure to return. Define a C# model first, then instruct the AI to match it.

public class InvoiceData
{
    public string?       InvoiceNumber { get; set; }
    public string?       VendorName    { get; set; }
    public string?       VendorAddress { get; set; }
    public DateTime?     InvoiceDate   { get; set; }
    public DateTime?     DueDate       { get; set; }
    public List<LineItem> LineItems    { get; set; } = [];
    public decimal?      Subtotal      { get; set; }
    public decimal?      TaxAmount     { get; set; }
    public decimal?      GrandTotal    { get; set; }
    public string?       Currency      { get; set; }
    public string?       PaymentTerms  { get; set; }
    public float         Confidence    { get; set; }
    public string?       Notes         { get; set; }
}

public class LineItem
{
    public string?  Description { get; set; }
    public decimal? Quantity    { get; set; }
    public decimal? UnitPrice   { get; set; }
    public decimal? Total       { get; set; }
}

Step 3: The Extraction Service

public class DocumentExtractionService : IDocumentExtractionService
{
    private readonly AzureOpenAIClient _client;
    private readonly IConfiguration    _config;

    public DocumentExtractionService(
        AzureOpenAIClient client,
        IConfiguration config)
    {
        _client = client;
        _config = config;
    }

    public async Task<InvoiceData?> ExtractInvoiceAsync(
        byte[] imageBytes,
        string mimeType = "image/jpeg")
    {
        var chatClient = _client.GetChatClient(_config["AzureOpenAI:Model"]);

        // Convert image to base64 data URI
        var base64 = Convert.ToBase64String(imageBytes);
        var dataUri = $"data:{mimeType};base64,{base64}";

        var prompt = """
            You are a precise document data extraction assistant.
            Extract all invoice data from this image and return it as JSON.

            Return ONLY valid JSON with this exact structure — no markdown, no explanation:
            {
              "invoiceNumber": "string or null",
              "vendorName":    "string or null",
              "vendorAddress": "string or null",
              "invoiceDate":   "YYYY-MM-DD or null",
              "dueDate":       "YYYY-MM-DD or null",
              "lineItems": [
                {
                  "description": "string",
                  "quantity":    number,
                  "unitPrice":   number,
                  "total":       number
                }
              ],
              "subtotal":    number or null,
              "taxAmount":   number or null,
              "grandTotal":  number or null,
              "currency":    "USD / GBP / AED / INR / etc.",
              "paymentTerms": "string or null",
              "confidence":   0.0 to 1.0,
              "notes": "any unusual observations about the document"
            }

            Rules:
            - Extract numbers as numeric values, not strings
            - If a field is not visible, return null
            - confidence = your estimate of extraction accuracy
            - Do not invent or guess values you cannot clearly read
            """;

        var messages = new List<ChatMessage>
        {
            new UserChatMessage(
                ChatMessageContentPart.CreateTextPart(prompt),
                ChatMessageContentPart.CreateImagePart(
                    new Uri(dataUri), null))
        };

        var response = await chatClient.CompleteChatAsync(
            messages,
            new ChatCompletionOptions
            {
                MaxOutputTokenCount = 2000,
                Temperature         = 0.1f  // Low temp = more deterministic output
            });

        var json = response.Value.Content[0].Text;

        // Strip markdown fences if the model adds them despite instructions
        json = json
            .Replace("```
{% endraw %}
json", "")
            .Replace("
{% raw %}
```",     "")
            .Trim();

        return JsonSerializer.Deserialize<InvoiceData>(json,
            new JsonSerializerOptions
            {
                PropertyNameCaseInsensitive = true
            });
    }
}

Processing Multiple Document Types with One Service
The real power is how easily you adapt the same pattern for different document types. Just change the prompt. Here's how we handle different document formats with a single extraction service by varying the prompt and output model.

// Generic extraction method — pass any prompt and expected output type
public async Task<T?> ExtractAsync<T>(
    byte[] imageBytes,
    string extractionPrompt,
    string mimeType = "image/jpeg") where T : class
{
    var chatClient = _client.GetChatClient(_config["AzureOpenAI:Model"]);
    var base64     = Convert.ToBase64String(imageBytes);
    var dataUri    = $"data:{mimeType};base64,{base64}";

    var schema = GenerateJsonSchema<T>(); // Use reflection or hard-coded schema

    var systemPrompt = $"""
        You are a precise document data extraction AI.
        Extract the requested data and return ONLY valid JSON.
        Schema to follow: {schema}
        If a field is not found in the document, set it to null.
        Do not return markdown, explanations, or commentary.
        """;

    var messages = new List<ChatMessage>
    {
        new SystemChatMessage(systemPrompt),
        new UserChatMessage(
            ChatMessageContentPart.CreateTextPart(extractionPrompt),
            ChatMessageContentPart.CreateImagePart(new Uri(dataUri), null))
    };

    var response = await chatClient.CompleteChatAsync(messages,
        new ChatCompletionOptions { Temperature = 0.1f });

    var json = response.Value.Content[0].Text.Trim()
        .TrimStart('`').TrimEnd('`')
        .Replace("json\n", "");

    return JsonSerializer.Deserialize<T>(json,
        new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
}

// Usage examples:

// Extract business card data
var card = await _extractor.ExtractAsync<BusinessCardData>(
    imageBytes,
    "Extract all contact information from this business card.");

// Extract medical form data
var form = await _extractor.ExtractAsync<MedicalFormData>(
    imageBytes,
    "Extract patient name, DOB, medications listed, and doctor name from this form.");

// Extract receipt data
var receipt = await _extractor.ExtractAsync<ReceiptData>(
    imageBytes,
    "Extract store name, date, all items purchased with prices, and total amount.");

Using It in a Blazor File Upload Flow
Here is how to wire this into a Blazor Server component where users upload an invoice image and see the extracted data instantly.

@page "/invoice-upload"
@inject IDocumentExtractionService Extractor

<h2>Upload Invoice</h2>

<InputFile OnChange="HandleFileSelected" accept="image/*,.pdf" />

@if (_loading)
{
    <p>Extracting data...</p>
}

@if (_invoice is not null)
{
    <div class="invoice-preview">
        <h3>@_invoice.VendorName — @_invoice.InvoiceNumber</h3>
        <p>Date: @_invoice.InvoiceDate?.ToString("d")</p>
        <p>Total: @_invoice.GrandTotal?.ToString("C") (@_invoice.Currency)</p>
        <p>Confidence: @(_invoice.Confidence * 100)%</p>

        <table>
            @foreach (var item in _invoice.LineItems)
            {
                <tr>
                    <td>@item.Description</td>
                    <td>@item.Quantity</td>
                    <td>@item.UnitPrice?.ToString("C")</td>
                    <td>@item.Total?.ToString("C")</td>
                </tr>
            }
        </table>
    </div>
}

@code {
    private bool        _loading = false;
    private InvoiceData? _invoice = null;

    private async Task HandleFileSelected(InputFileChangeEventArgs e)
    {
        _loading = true;
        _invoice = null;

        try
        {
            var file   = e.File;
            var buffer = new byte[file.Size];

            await using var stream = file.OpenReadStream(maxAllowedSize: 10 * 1024 * 1024);
            await stream.ReadExactlyAsync(buffer);

            _invoice = await Extractor.ExtractInvoiceAsync(
                buffer, file.ContentType);
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine($"Extraction failed: {ex.Message}");
        }
        finally
        {
            _loading = false;
        }
    }
}

Handling PDFs — Converting Pages to Images First
The vision API accepts images, not PDFs. For multi-page PDF invoices, convert each page to a JPEG first, then process each page separately. We use the open-source PDFium library for this in .NET.

// Install: dotnet add package PdfiumViewer.Native.x86_64.v8-xfa
// Install: dotnet add package PdfiumViewer

public async Task<List<InvoiceData?>> ExtractFromPdfAsync(byte[] pdfBytes)
{
    var results = new List<InvoiceData?>();

    using var stream    = new MemoryStream(pdfBytes);
    using var document  = PdfDocument.Load(stream);

    for (int page = 0; page < document.PageCount; page++)
    {
        // Render at 200 DPI for good quality
        using var image  = document.Render(page, 200, 200, false);
        using var ms     = new MemoryStream();
        image.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg);

        var pageBytes = ms.ToArray();
        var result    = await ExtractInvoiceAsync(pageBytes, "image/jpeg");

        if (result is not null)
            results.Add(result);
    }

    return results;
}

Accuracy, Cost, and When to Use AI vs Traditional OCR
AI extraction is not free. GPT-4o charges per token and image tokens are significant. Here's a practical breakdown to help you decide:

Use AI extraction when:
• Documents come in many formats from different sources (invoices, contracts, forms)
• Accuracy is critical and manual correction is expensive
• Documents contain handwriting, stamps, or non-standard layouts
• You need structured data, not just raw text
• Volume is moderate (hundreds per day, not millions)

Use traditional OCR when:
• Documents are always the same template (your own forms)
• Volume is very high (millions per day) and cost matters at scale
• You only need raw text extraction, not structured fields
• Latency is critical (OCR is faster than an API call)

For typical business document processing — invoices, medical records, legal forms, receipts — AI extraction saves significant development time and delivers higher accuracy than any traditional pipeline I've built. The prompt is your only maintenance surface. When a new document layout appears, you adjust the prompt — not the code.

Tips for Production Reliability

Always validate the output — check that numeric totals add up, required fields are non-null, and dates are valid before saving to your database.
Use temperature 0.1 — lower temperature makes the model more deterministic and consistent. High temperature introduces unnecessary variation in data extraction.
Include a confidence score in the prompt — instruct the model to rate its own confidence. Flag anything below 0.85 for human review rather than auto-processing.
Log the raw response — always log the raw JSON string from the model before parsing. This makes debugging extraction failures much easier.
Handle rate limits — Azure OpenAI has tokens-per-minute limits. For batch processing, add a retry with exponential backoff using Polly.

// Polly retry policy for rate limiting
services.AddHttpClient<IDocumentExtractionService>()
    .AddResilienceHandler("openai-retry", builder =>
    {
        builder.AddRetry(new HttpRetryStrategyOptions
        {
            MaxRetryAttempts = 4,
            Delay            = TimeSpan.FromSeconds(2),
            BackoffType      = DelayBackoffType.Exponential,
            UseJitter        = true,
            ShouldHandle     = args => args.Outcome.Result?.StatusCode
                               == System.Net.HttpStatusCode.TooManyRequests
                               ? PredicateResult.True()
                               : PredicateResult.False()
        });
    });

I'm Kathan, a freelance .NET dev. If this helped, check out my website — I'm available for contract work.

Building a Legal Tech Automation System: Syncing Clio, Lawmatics, Zoom & Box Using .NET Hangfire

kathan — Thu, 30 Apr 2026 11:44:59 +0000

Law firms run on data — contacts, matters, call recordings, transcripts, documents. The problem is that data lives in four different platforms that don't talk to each other. Clio and Lawmatics handle case management. Zoom handles calls. Box handles document storage. Every day, staff manually copy contacts, chase recordings, and create folders. That's exactly the workflow we automated.

This post documents the full architecture we built for a US-based law firm — North City Law — using ASP.NET Core, Hangfire, and the REST APIs of all four platforms. If you're building legal tech integrations or any multi-platform sync system, the patterns here apply directly.

The Problem — Four Platforms, Zero Sync
Here's what the firm's manual workflow looked like before automation:

A new client is added to Lawmatics (their CRM)
Staff manually add the same contact to Zoom's external contacts
A call happens — Zoom generates a recording, AI summary, and transcript
Staff download the transcript and paste it as a note in Clio
A new matter opens in Clio — staff manually create a Box folder and upload documents

This process consumed 2–3 hours of admin work daily and introduced errors at every manual step. Our goal: make all of it happen automatically, on a schedule, without human intervention.

Architecture Overview
The system is built on Blazor Server + ASP.NET Core + Hangfire, hosted on Azure App Service. Each integration is a Hangfire recurring job that runs on a configurable schedule. OAuth 2.0 tokens for each platform are stored encrypted in a SQL Server database and refreshed automatically.

The four core jobs are:

Job 1: Sync contacts from Clio/Lawmatics → Zoom External Contacts (every 6 hours)
Job 2: Pull Zoom call recordings, AI summaries, and transcripts → post as notes in Clio/Lawmatics (daily at 7 AM)
Job 3: Monitor new matters in Clio → create corresponding Box folder structure (triggered on schedule every 15 minutes)
Job 4: Upload matter documents from Clio → Box folder (daily at 6 AM)

Setting Up Hangfire with SQL Server
Hangfire is the backbone of the scheduling system. It stores job state in SQL Server, handles retries automatically, and provides a dashboard to monitor every job run.

// Program.cs
builder.Services.AddHangfire(config => config
    .SetDataCompatibilityLevel(CompatibilityLevel.Version_180)
    .UseSimpleAssemblyNameTypeSerializer()
    .UseRecommendedSerializerSettings()
    .UseSqlServerStorage(builder.Configuration.GetConnectionString("HangfireDb"),
        new SqlServerStorageOptions
        {
            CommandBatchMaxTimeout       = TimeSpan.FromMinutes(5),
            SlidingInvisibilityTimeout   = TimeSpan.FromMinutes(5),
            QueuePollInterval            = TimeSpan.Zero,
            UseRecommendedIsolationLevel = true,
            DisableGlobalLocks           = true
        }));

builder.Services.AddHangfireServer(options =>
{
    options.WorkerCount    = 5;
    options.Queues         = new[] { "critical", "default", "low" };
});

// Register recurring jobs after app builds
var app = builder.Build();

using (var scope = app.Services.CreateScope())
{
    var recurringJobs = scope.ServiceProvider
        .GetRequiredService<IRecurringJobManager>();

    // Every 6 hours — sync contacts to Zoom
    recurringJobs.AddOrUpdate<ContactSyncJob>(
        "sync-contacts-to-zoom",
        job => job.ExecuteAsync(),
        "0 */6 * * *");

    // Daily at 7 AM UTC — sync Zoom recordings to Clio notes
    recurringJobs.AddOrUpdate<ZoomRecordingSyncJob>(
        "sync-zoom-recordings-to-clio",
        job => job.ExecuteAsync(),
        "0 7 * * *");

    // Every 15 minutes — check for new Clio matters
    recurringJobs.AddOrUpdate<NewMatterBoxJob>(
        "create-box-folders-for-new-matters",
        job => job.ExecuteAsync(),
        "*/15 * * * *");
}

Job 1: Syncing Contacts from Clio/Lawmatics to Zoom
The Clio API returns contacts with full contact details. We map these to Zoom's External Contact format and use the Zoom API to upsert them. The key challenge is matching contacts that already exist in Zoom — we match on phone number since names can differ between systems.

public class ContactSyncJob
{
    private readonly IClioService    _clio;
    private readonly IZoomService    _zoom;
    private readonly ILogger<ContactSyncJob> _logger;

    public ContactSyncJob(
        IClioService clio,
        IZoomService zoom,
        ILogger<ContactSyncJob> logger)
    {
        _clio   = clio;
        _zoom   = zoom;
        _logger = logger;
    }

    public async Task ExecuteAsync()
    {
        _logger.LogInformation("Starting contact sync at {Time}", DateTime.UtcNow);

        // Fetch all contacts from Clio (paginated)
        var clioContacts = await _clio.GetAllContactsAsync();

        // Fetch existing Zoom external contacts for deduplication
        var zoomContacts = await _zoom.GetExternalContactsAsync();
        var zoomByPhone  = zoomContacts
            .Where(z => !string.IsNullOrEmpty(z.Phone))
            .ToDictionary(z => z.Phone!.NormalizePhone(), z => z);

        int created = 0, updated = 0, skipped = 0;

        foreach (var contact in clioContacts)
        {
            try
            {
                var normalized = contact.PrimaryPhone?.NormalizePhone();

                if (string.IsNullOrEmpty(normalized))
                {
                    skipped++;
                    continue;
                }

                if (zoomByPhone.TryGetValue(normalized, out var existing))
                {
                    // Update if name changed
                    if (existing.DisplayName != contact.DisplayName)
                    {
                        await _zoom.UpdateExternalContactAsync(existing.Id, new ZoomContactRequest
                        {
                            DisplayName = contact.DisplayName,
                            Email       = contact.Email,
                            Phone       = contact.PrimaryPhone
                        });
                        updated++;
                    }
                }
                else
                {
                    await _zoom.CreateExternalContactAsync(new ZoomContactRequest
                    {
                        DisplayName = contact.DisplayName,
                        Email       = contact.Email,
                        Phone       = contact.PrimaryPhone
                    });
                    created++;
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex,
                    "Failed to sync contact {Name}", contact.DisplayName);
            }
        }

        _logger.LogInformation(
            "Contact sync complete. Created: {C}, Updated: {U}, Skipped: {S}",
            created, updated, skipped);
    }
}

Job 2: Syncing Zoom Recordings and AI Summaries to Clio Notes
This is the most valuable part of the automation. Zoom's API provides three assets per meeting: the recording file URL, an AI-generated summary, and a full transcript. We download all three and post them as a structured note in Clio against the matching contact.

public class ZoomRecordingSyncJob
{
    private readonly IZoomService       _zoom;
    private readonly IClioService       _clio;
    private readonly ISyncStateService  _state;
    private readonly ILogger<ZoomRecordingSyncJob> _logger;

    public async Task ExecuteAsync()
    {
        // Only fetch recordings since last successful sync
        var lastSync = await _state.GetLastSyncTimeAsync("zoom-recordings");
        var fromDate = lastSync ?? DateTime.UtcNow.AddDays(-1);

        _logger.LogInformation("Fetching Zoom recordings since {From}", fromDate);

        var meetings = await _zoom.GetCloudRecordingsAsync(
            from: fromDate,
            to:   DateTime.UtcNow);

        foreach (var meeting in meetings)
        {
            try
            {
                // Try to match the meeting host/participant to a Clio contact
                var clioContact = await _clio
                    .FindContactByEmailAsync(meeting.HostEmail);

                if (clioContact is null)
                {
                    _logger.LogWarning(
                        "No Clio contact found for {Email}",
                        meeting.HostEmail);
                    continue;
                }

                // Build a rich note from all three Zoom assets
                var noteBody = BuildNoteContent(meeting);

                await _clio.CreateNoteAsync(new ClioNoteRequest
                {
                    Subject  = $"Zoom Call — {meeting.Topic} ({meeting.StartTime:MMM dd, yyyy})",
                    Body     = noteBody,
                    ContactId = clioContact.Id,
                    Date     = meeting.StartTime
                });

                _logger.LogInformation(
                    "Posted note for meeting {Topic} to contact {Name}",
                    meeting.Topic, clioContact.DisplayName);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex,
                    "Failed to sync meeting {Id}", meeting.Id);
            }
        }

        await _state.SetLastSyncTimeAsync("zoom-recordings", DateTime.UtcNow);
    }

    private static string BuildNoteContent(ZoomMeeting meeting)
    {
        var sb = new StringBuilder();

        sb.AppendLine($"**Meeting:** {meeting.Topic}");
        sb.AppendLine($"**Date:** {meeting.StartTime:f}");
        sb.AppendLine($"**Duration:** {meeting.Duration} minutes");
        sb.AppendLine($"**Host:** {meeting.HostEmail}");
        sb.AppendLine();

        if (!string.IsNullOrEmpty(meeting.AiSummary))
        {
            sb.AppendLine("## AI Summary");
            sb.AppendLine(meeting.AiSummary);
            sb.AppendLine();
        }

        if (!string.IsNullOrEmpty(meeting.Transcript))
        {
            sb.AppendLine("## Call Transcript");
            // Truncate to 5000 chars — Clio notes have limits
            var transcript = meeting.Transcript.Length > 5000
                ? meeting.Transcript[..5000] + "\n\n[Transcript truncated — see Zoom for full version]"
                : meeting.Transcript;
            sb.AppendLine(transcript);
        }

        if (!string.IsNullOrEmpty(meeting.RecordingUrl))
        {
            sb.AppendLine();
            sb.AppendLine($"[View Full Recording]({meeting.RecordingUrl})");
        }

        return sb.ToString();
    }
}

Job 3: Auto-Creating Box Folders When a New Matter Opens
When a lawyer opens a new matter in Clio, the firm needs a Box folder created immediately with the correct naming convention and subfolder structure. We poll Clio's matters API every 15 minutes looking for matters created since the last check, then create the Box folder hierarchy.

public class NewMatterBoxJob
{
    private readonly IClioService      _clio;
    private readonly IBoxService       _box;
    private readonly ISyncStateService _state;
    private readonly ILogger<NewMatterBoxJob> _logger;

    // The root Box folder ID where all matter folders live
    private const string ROOT_FOLDER_ID = "your-root-box-folder-id";

    public async Task ExecuteAsync()
    {
        var lastCheck = await _state.GetLastSyncTimeAsync("new-matters")
                        ?? DateTime.UtcNow.AddMinutes(-15);

        var newMatters = await _clio.GetMattersCreatedAfterAsync(lastCheck);

        foreach (var matter in newMatters)
        {
            try
            {
                // Check if folder already exists (idempotency guard)
                var folderName  = BuildFolderName(matter);
                var existingId  = await _box.FindFolderByNameAsync(
                    ROOT_FOLDER_ID, folderName);

                if (existingId is not null)
                {
                    _logger.LogInformation(
                        "Box folder already exists for matter {Id}", matter.Id);
                    continue;
                }

                // Create parent matter folder
                var matterFolderId = await _box.CreateFolderAsync(
                    parentId: ROOT_FOLDER_ID,
                    name:     folderName);

                // Create standard subfolder structure
                var subfolders = new[]
                {
                    "Correspondence",
                    "Pleadings",
                    "Discovery",
                    "Contracts",
                    "Research",
                    "Billing"
                };

                foreach (var sub in subfolders)
                {
                    await _box.CreateFolderAsync(
                        parentId: matterFolderId,
                        name:     sub);
                }

                // Store Box folder ID back in Clio custom field
                await _clio.UpdateMatterCustomFieldAsync(
                    matterId:    matter.Id,
                    fieldName:   "box_folder_id",
                    fieldValue:  matterFolderId);

                _logger.LogInformation(
                    "Created Box folder structure for matter: {Name}",
                    matter.DisplayNumber);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex,
                    "Failed to create Box folder for matter {Id}", matter.Id);
            }
        }

        await _state.SetLastSyncTimeAsync("new-matters", DateTime.UtcNow);
    }

    private static string BuildFolderName(ClioMatter matter)
    {
        // Format: "2025-001 — Smith v Jones"
        var sanitized = Regex.Replace(
            matter.DisplayNumber + " — " + matter.Description,
            @"[\\/:*?""<>|]", "_");
        return sanitized[..Math.Min(sanitized.Length, 100)];
    }
}

OAuth 2.0 Token Management — The Part Everyone Gets Wrong
All three APIs (Clio, Lawmatics, Zoom) use OAuth 2.0. Tokens expire. If your Hangfire job runs at 3 AM and the access token expired at 2 AM, the job fails silently. The solution is a dedicated token service that automatically refreshes before every API call.

public class TokenService : ITokenService
{
    private readonly AppDbContext _db;
    private readonly IHttpClientFactory _http;

    public async Task<string> GetValidTokenAsync(string platform)
    {
        var stored = await _db.OAuthTokens
            .FirstOrDefaultAsync(t => t.Platform == platform)
            ?? throw new InvalidOperationException(
                $"No token found for {platform}. Re-authenticate.");

        // Refresh if token expires within the next 5 minutes
        if (stored.ExpiresAt <= DateTime.UtcNow.AddMinutes(5))
        {
            stored = await RefreshTokenAsync(stored);
        }

        return Decrypt(stored.AccessTokenEncrypted);
    }

    private async Task<OAuthToken> RefreshTokenAsync(OAuthToken token)
    {
        var client   = _http.CreateClient();
        var platform = GetPlatformConfig(token.Platform);

        var response = await client.PostAsync(
            platform.TokenEndpoint,
            new FormUrlEncodedContent(new Dictionary<string, string>
            {
                ["grant_type"]    = "refresh_token",
                ["refresh_token"] = Decrypt(token.RefreshTokenEncrypted),
                ["client_id"]     = platform.ClientId,
                ["client_secret"] = platform.ClientSecret
            }));

        response.EnsureSuccessStatusCode();

        var result = await response.Content
            .ReadFromJsonAsync<OAuthTokenResponse>();

        token.AccessTokenEncrypted  = Encrypt(result!.AccessToken);
        token.ExpiresAt             = DateTime.UtcNow
                                        .AddSeconds(result.ExpiresIn - 60);

        if (!string.IsNullOrEmpty(result.RefreshToken))
            token.RefreshTokenEncrypted = Encrypt(result.RefreshToken);

        _db.OAuthTokens.Update(token);
        await _db.SaveChangesAsync();

        return token;
    }

    // AES-256 encryption for stored tokens
    private string Encrypt(string plainText) { /* AES-256-CBC impl */ }
    private string Decrypt(string cipherText) { /* AES-256-CBC impl */ }
}

Results and What This Saved
After deploying this system, the results were immediate. The firm eliminated approximately 2–3 hours of daily admin work, removed all manual copy-paste errors between systems, and ensured every Zoom call automatically appeared as a structured note in Clio within hours — without anyone touching a keyboard.

The Hangfire dashboard gave the firm's operations lead full visibility into every job run, every failure, and every retry — so when Zoom's API had a 20-minute outage one morning, the jobs simply queued and completed automatically when the service came back online.

Key Takeaways
If you're building similar multi-platform integrations in .NET, these are the principles that saved us the most time:

1. Store sync state — always record the last successful sync timestamp. Never re-process everything from the beginning.
2. Match on stable identifiers — phone numbers and emails are more reliable than names across systems.
3. Make jobs idempotent — running a job twice should produce the same result as running it once.
4. Encrypt tokens at rest — OAuth tokens are credentials. Treat them like passwords.
5. Use Hangfire's dashboard — give your client visibility into the automation. It builds trust and surfaces issues before they become problems.

I'm Kathan, a freelance .NET dev. If this helped, check out my website — I'm available for contract work.