Solutions Engineering, Integrations & Full-Stack Development

I build B2B SaaS integrations, secure APIs, and transactional database pipelines.

Compliance-Aware Software Engineering & Financial Systems Controls

I design, scope, and implement secure B2B SaaS integrations, custom database migrations, and transactional middleware. Combining full-stack engineering with a Master of Accounting background, I build clean, auditable systems that respect internal controls, secure schema contracts, and strict validation rules.

Estimate manual cost See build paths
Local RAG Agentic routing Support triage Invoice parsing AIOS / agents Sovereign VPC Air-gapped runtime Private ops dashboards
Free workflow review

See if one workflow is worth building.

Send details of a bottleneck workflow. I will review the process and recommend either a no-build tool fix, a focused repair, or a custom build sprint.

Response within one business day. If it is not worth building, I will say so.
Prefer a Loom or short note? Email it instead.
Try the live RAG demo
How the first project works
01 Share the manual workflow
02 Map data and failure cases
03 Review fixed quote
04 Ship with logs and review paths
Open-weight operational playbooks

Private automation built on local runtime architectures.

Zero-leakage data boundaries, fixed-cost inference options, and deterministic software around every model call. No loose GPT wrapper, no invisible third-party data collection, no variable token margin hiding inside the workflow.

Playbook 01 Advanced RAG

The Local Knowledge Sovereign

Problem

Enterprise teams lose hours parsing internal PDFs, contracts, customer notes, and support history, but compliance rules forbid pasting sensitive files into public-hosted LLM endpoints.

Local architecture
  • Data layer: File intake lands in private PostgreSQL with pgvector, permissions, and source IDs intact.
  • Inference layer: Local embeddings chunk and index text; a Llama, Qwen, or Mistral node synthesizes cited answers on private infrastructure.

Boundary: Business documents never traverse public model networks. Token margin on local inference is $0.00; operating cost is infrastructure you can inspect.

Playbook 02 Routing

Local Multi-agent Triage

Problem

Inbound leads, support tickets, and operational requests need intelligent parsing and CRM enrichment, but variable cloud API latency and uptime can break real-time customer loops.

Local architecture
  • Deterministic filter: Backend logic validates JSON schemas, permissions, known accounts, and required fields before any model is called.
  • Inference layer: A small local model handles structured tool calling and classification in low-latency bursts on Ollama or vLLM.

Boundary: Ambiguous payloads, malformed fields, and confidence failures skip auto-routing and land in a human review dashboard.

Playbook 03 Fintech & ERP

Multi-Vendor Transaction & 3PL Sync

Problem

E-commerce and SaaS merchants lose hours manually reconciliating invoices, tracking payouts, and syncing multi-vendor fulfillments, leading to audit trail gaps and support backlog.

System Architecture
  • API integration: Direct Shopify Admin GraphQL queries pull nested fulfillmentOrders by transactional parameters.
  • Ledger mapping: A secure Supabase or PostgreSQL layer normalizes billing logs, validates data, and runs transactional mutations.

Controls: Automatic schema validation blocks double-fulfillment, catches mismatched line items, and logs full audit trails for reviews.

Production architecture

Local where it matters. Deterministic everywhere.

Slake designs workflow systems around private data boundaries, direct queries, and fixed-cost inference options. Local open-weight models are useful when privacy, latency, or margin matters; they still sit behind schemas, validation, logs, and review paths.

Examples

See the work before we talk.

Marketplace search build A client build example for marketplace search where users describe what they want in plain language. Live RAG demo Ask Stripe docs a question and see scoped retrieval, citations, and a bounded answer. Systems notes Short guides on AI search, lead routing, invoice workflows, and build-vs-buy decisions.
Simple next step Send one workflow. I will tell you whether it needs software, search, or no build.
RETRIEVAL DEMO
Stripe docs
[14:22:01] Loading Stripe docs into retrieval context
[14:22:02] Finding relevant source passages
[14:22:03] Drafting an answer with cited context
"For multi-party payouts in Stripe Connect, use Account Tokens for KYC-less onboarding layers while maintaining split-fee logic in the Transfer API..."
Working retrieval demo

See how grounded AI search works before we talk.

The demo shows the unstructured-data side only: retrieve source passages, cite them, and draft a reviewable answer. Production systems query structured records first. Retrieval runs only when direct queries cannot fully answer the question.

Try the live demo
[ COMMON_AI_WORKFLOWS ]

Where AI usually pays for itself first

The best first build is rarely a giant AI transformation. It is one recurring workflow where your team already knows the pain and the data already exists.

[ DOCUMENTS ]

Document lookup and review

Teams search PDFs, contracts, support docs, invoices, job files, or internal notes before they can answer basic operational questions.

The Fix: A grounded AI search layer that finds the right source, summarizes it, and cites where the answer came from.
[ LEADS ]

Lead routing and follow-up

Inbound leads sit in inboxes, forms, CRMs, or spreadsheets while someone manually qualifies, tags, assigns, and drafts next steps.

The Fix: An AI routing loop that classifies the lead, enriches context, updates the CRM, and triggers the right follow-up.
[ OPERATIONS ]

Data entry, reporting, and dashboards

People copy information between email, spreadsheets, billing tools, CRMs, and dashboards because the systems do not talk cleanly.

The Fix: A coded workflow layer that extracts, validates, syncs, and turns the data into review queues or dashboards with traceable failure handling.
Working demo

Ask Stripe documentation a technical question and see the retrieval pattern behind internal docs search, support triage, and bounded implementation support.

Try the demo
Manual workflow cost

What is the manual work costing you?

A small workflow can quietly burn thousands of dollars a year when senior people are searching, copying, routing, and rechecking work by hand. This starts at a realistic operator scenario; adjust it down if your pain is smaller.

20 hrs

Time spent searching, copying, routing, or rechecking

$75/hr

Includes a simple 1.3x labor burden estimate

Burden Multiplier 1.3x
Effective Hourly Cost $98/hr
Annual Manual Time 1,040 hrs
Estimated annual drag
$101,400

If that number feels too high, test it with one workflow.

Send the workflow that creates the drag. I will tell you whether it is worth building, whether a simpler fix is better, and what a fixed-scope build would require.

Review this workflow Send a Loom

Built on private runtime, deterministic code, and the tools your team already uses.

Ollama
vLLM
Llama
Mistral
Qwen
Supabase
pgvector
Postgres
LangChain
Slack
FastAPI
HubSpot
n8n
Python
Docker
Private VPC
Azure OpenAI
OpenAI
Anthropic
[PREPARATION_LAYER]

What helps me review the workflow

  • One Workflow: A concrete loop where people constantly hunt for information.
  • One Real Example: A live ticket, job, or deal you can pull up on screen.
  • Access: Ability to screen‑share the tools that hold that data (CRM, Drive, etc.).
  • Decision Maker: Someone on the call who can speak for budget and environment access.

How the workflow review and build sprint work

A simple path from messy manual work to a deployed workflow your team can inspect, test, and adjust.

01

Step 1: Find the Workflow

We identify one manual loop with clear inputs and outputs: lead routing, document lookup, support triage, CRM cleanup, invoice work, or internal reporting.

02

Scope + Fixed Quote

You get a plain-English workflow map, data-boundary notes, likely failure cases, technical plan, and fixed-price build quote within 72 hours.

Simple ROI check
ROI = (Cmanual × Erate) - (Cai + Coversight)
Manual hours x loaded hourly cost - build and oversight cost.
03

Build Sprint

Build and deploy the workflow in 2 to 4 weeks with validation layers, logs, and a human review path for exceptions. You own the code and data infrastructure.

What a useful first build looks like

One painful workflow, one clear system, one measurable improvement.

Example proposal

"Stop passing permit PDFs around in email. Move to a live job record where permit requirements, status, and documents are all attached to the work order."

Why it works

  • Data Integrity: One source of truth instead of conflicting versions in inboxes.
  • Speed: Crews see exactly what’s approved and what’s missing without asking ops.
  • Result: Fewer delays, less rework, measurable drop in Field Ops Information Tax.
Common first builds

Workflow systems small teams actually use

Start where the pain is obvious: search, routing, triage, reporting, and admin loops with inputs, rules, outputs, and known failure cases.

AI search

Docs and knowledge search

Best for SaaS teams, agencies, and ops-heavy businesses with scattered internal knowledge.

Search PDFs, docs, support content, product specs, or API references and return answers with citations your team can verify. Retrieval is limited to unstructured source material.

USE_CASE: Internal docs search, support knowledge, technical FAQ, customer-facing help.
Routing and triage

Lead and support routing

Best for founders, sales leaders, and support teams where speed matters.

Classify inbound requests, enrich context from records, update the CRM or helpdesk, and alert the right person. Ambiguous cases are flagged instead of auto-routed.

USE_CASE: Demo requests, support inboxes, churn-risk tickets, referral follow-up.
Admin workflows

Invoice, CRM, and dashboard workflows

Best for teams where founders or senior staff still do repetitive admin work.

Extract, validate, sync, and report data between email, CRM, billing, spreadsheets, dashboards, and internal tools. Bad parses and missing fields go to review.

USE_CASE: Invoices, onboarding, CRM hygiene, ops dashboards, document intake.

Why custom code instead of another no-code chain?

01
Reliable handoffs.

Custom code gives you version control, logs, tests, and explicit failure handling when the workflow matters enough to stop duct-taping it together.

02
Fixed-scope builds.

Most first builds land in a $4,000 to $8,000 sprint once the workflow is clear. You know what is being built before the meter starts running.

03
One person from scope to handoff.

You work directly with the person mapping the workflow, building the system, and handing over maintainable source code.

Practical safeguards
What should I send first?
Send one repeated workflow: what triggers it, which tools are involved, who touches it, and where work slows down. A Loom, screenshot, or short written note is enough.
What if my data is messy?
That is common. The first review checks whether the data is usable now, needs cleanup first, or should be handled with rules and human review instead of AI.
When is custom better than SaaS or no-code?
When the workflow crosses multiple tools, depends on business-specific logic, needs source-cited answers, or requires logs and failure handling. If an off-the-shelf tool is the better answer, I will say so.
Will this create another app my team ignores?
The goal is usually the opposite. Good builds sit inside the tools your team already uses: email, Slack, CRM, helpdesk, docs, spreadsheets, or an existing admin system.
Who owns the code and handoff?
After full payment, you own the custom deliverables. I provide setup notes, environment requirements, and enough context for your team or another developer to maintain the system.
Is my data used to train an LLM?
I choose providers and architecture patterns that keep your business data out of generic model training. Exact handling, retention, and access rules are defined before implementation.
What will this cost to run?
You see expected hosting, model, storage, and API costs before build. Most first systems are inexpensive to operate compared with the staff time they replace.
What happens after launch?
Build sprints include 30 days of support for defects in the original implementation, plus handoff notes and a clear path for monitoring or future improvements.