corey.consulting

Development

The technical side of the work.

Most of my engagements involve building something — a custom web application, an internal tool, a data pipeline, an integration, an automation. This page is the technical slice of that work. Here's what I actually build when the work calls for code.

See the full picture

What I build

Custom builds, not templated stacks.

Four areas cover most of the technical work. Engagements rarely sit cleanly inside one — a real build usually pulls from two or three at once.

01

Web applications and marketing sites

Custom Next.js and React builds — the actual product, not a templated landing page. Designed to be fast, accessible, and easy for a non-engineer to update once it ships.

  • Next.js (App Router) and React
  • TypeScript end-to-end
  • Responsive UI built to a real design system
  • Static export and edge-rendered hosting
02

APIs, integrations, and back-end services

The plumbing that makes a system actually work — auth, third-party APIs, webhooks, and the back-end services that hold a business together when the front door is busy.

  • Node.js and Express services
  • REST and webhook integrations
  • Auth, sessions, and rate limiting
  • Background jobs and queue workers
03

Dashboards, analytics, and data pipelines

Custom reporting that answers the questions your off-the-shelf tool won't. Event tracking wired into a warehouse, dashboards that match how you actually run the business, and the pipelines that keep them honest.

  • Event tracking and instrumentation
  • Custom analytics dashboards
  • Data modeling and reporting
  • ETL and pipeline orchestration
04

AI and automation systems

Practical automation built around the work — research pipelines, content generation, internal-ops agents, and customer-facing workflows. Designed so the team using it understands what the model is doing and where the seams are.

  • LLM-powered workflows (Claude, GPT, Gemini)
  • Research and data-analysis pipelines
  • Agent-based automation for ops and support
  • Prompt engineering and evaluation

Stack and tools

The tools I actually use.

Stack choice follows the work, not the other way around. This is the working set — what I reach for first, and what I bring into engagements when there's no incumbent preference.

Frontend

  • React
  • Next.js (App Router)
  • TypeScript
  • Tailwind CSS
  • Responsive UI / design systems

Backend

  • Node.js
  • Express
  • REST and webhook APIs
  • Auth and session handling
  • Postgres and MongoDB

Data and analytics

  • Event tracking
  • Custom dashboards
  • Data modeling
  • Reporting pipelines
  • Warehouse and ETL

AI and automation

  • Prompt engineering
  • Workflow automation
  • LLM orchestration
  • Agent design
  • Evaluation and guardrails

Tools and platforms

  • Vercel and Netlify
  • GitHub Actions
  • Asana workflow integration
  • Cloud deployment (AWS, GCP)
  • Custom logging and tracing

How a build runs

Diagnose. Design. Build. Deploy.

No discovery phase, no onboarding tax, no slide deck about what I would do. The first deliverable lands inside the first week — and the architecture has already been thought through end-to-end before a line of code is written.

  1. 01

    Diagnose

    Map the real work, the real users, and the real bottlenecks. The build brief comes out of this — not a kickoff deck.

  2. 02

    Design

    Architect the system end-to-end before writing it. Data model, integrations, edge cases, and the seams a future team will have to live with.

  3. 03

    Build

    Write the actual code. Custom application, internal tool, integration, or automation — built in week one, not after a discovery phase.

  4. 04

    Deploy and optimize

    Get it live, instrument it, and tune it against real usage. Hand it off with the documentation and tests a working team can actually maintain.

Let's see if this fits.

Send me a message and tell me what you're dealing with. One conversation is usually enough to know if I'm the right fit — and if I'm not, I'll usually know someone who is.