Skip to content

AI & Automation Engineer

AI / Automation Engineer

AI and automation practice with the engineering work made explicit

I have not launched AI products for paying customers. What I can show is local model work, FastAPI experiments, prompt documentation, and small automation workflows with clear limits.
  • Convo-AI: FastAPI backend, local model orchestration, and environment setup work.
  • Automation: scripts and workflows that support personal projects and content pipelines.
  • Documentation: prompt notes, disclosure of AI-assisted code, and manual review steps.
Honesty upgrade

Clear scope, upfront

What I have

  • Local AI experiments that run on my personal development machine.
  • Documented prompts, edits, and limitations in READMEs.
  • Basic automation scripts tied to personal projects.

What I am still working toward

  • Production AI integrations or real-user telemetry pipelines.
  • Enterprise guardrails, audits, or policy enforcement.
  • Large-scale orchestration across teams and systems.

What I’m doing next

  • Better evaluation workflows for outputs and hallucinations.
  • Richer prompt orchestration with queues + storage.
  • Security and privacy reviews before public releases.
Reality snapshot

Current focus

Local-first experiments

The engineering part of this work is in the backend setup, local model hosting, environment configuration, and getting the workflow to run reliably on one machine.

  • Convo-AI runs a FastAPI backend with Ollama locally for chat workflows.
  • No services are hosted for external users; all workloads run locally.

Documentation + prompts

I treat prompt work like another engineering artifact: useful only if it is documented, reproducible, and paired with manual review.

  • Prompt libraries and README logs documenting which content was AI-drafted and which content was manually edited.
  • Projects include TODOs for evaluation, safety, and more reliable workflow control.
Work samples

Proof on GitHub

Convo-AI

Engineering focus: FastAPI backend, local model workflow, environment variables, and end-to-end local setup.

  • FastAPI backend + simple UI for local chat flows.
  • Uses Ollama models and environment variables documented in the repo.
  • Disclosure: AI drafted the initial version of most endpoints; prompts and subsequent edits are documented in the README.

Proof links: Convo-AI

AI workflow notes

Engineering focus: how prompts, validation, disclosure, and manual review fit into the build process instead of replacing it.

  • Documented how I structure AI-assisted builds and where I still rely on manual checks.
  • Focus is on transparency regarding what AI drafted and what was rewritten manually.

Proof links: AI workflow post

Tools

What I’m experimenting with

Python + FastAPI — learningNode.js / Express — prototypesLangChain — exploringOllama + local LLMs — local onlyOpenAI / Anthropic APIs — experimentsSupabase — exploring vector storesGitHub Actions — small deploys

Each repository labels working features versus experimental or aspirational features to indicate maturity level.

Help wanted

What I still need to learn

  • Responsible AI guardrails (policy checks, escalation paths) in production environments.
  • Measuring ROI beyond “this feels faster on my laptop.”
  • Scaling prompt orchestration with queues, storage, and audit requirements.
  • Security/privacy reviews for AI features before they reach real users.

If you mentor junior engineers on applied AI or automation, I am open to pairing sessions.

Core Responsibilities

An AI & Automation Engineer is responsible for building, integrating, and maintaining automated workflows and AI-powered features. Key responsibilities include:

  • LLM integration: Connecting applications to large language model APIs (OpenAI, Anthropic) for chat, summarization, and extraction tasks.
  • Agent workflow design: Orchestrating multi-step AI agent pipelines using frameworks like LangChain for tool use, retrieval, and reasoning chains.
  • Local model hosting: Running open-weight models locally with Ollama for development and prototyping without external API costs.
  • Backend service development: Building REST APIs with FastAPI to serve AI endpoints with typed validation and automatic OpenAPI docs.
  • Prompt engineering and documentation: Treating prompts as versioned engineering artifacts with documented inputs, expected outputs, and manual review checkpoints.
  • Evaluation and safety: Designing evaluation workflows to detect hallucinations, measure output quality, and enforce safety guardrails before features reach users.
  • Automation scripting: Writing Python and Node.js scripts to automate content pipelines, data processing, and repetitive development tasks.

Key Skills

  • Programming languages: Python (Source), JavaScript/TypeScript (Source)
  • Web frameworks: FastAPI (Source), Express.js (Source)
  • AI/ML frameworks: LangChain (Source), Ollama (Source)
  • LLM APIs: OpenAI API (Source), Anthropic API (Source)
  • Vector stores: Supabase pgvector (Source), Chroma (Source)
  • CI/CD: GitHub Actions (Source)
  • Evaluation: RAGAS for RAG evaluation (Source), manual review workflows

Tools and Technologies

ToolCategoryMy Maturity LevelOfficial Docs
Python + FastAPIBackend frameworkLearningFastAPI
Node.js / ExpressBackend frameworkPrototypesExpress
LangChainLLM orchestrationExploringLangChain
OllamaLocal LLM hostingLocal onlyOllama
OpenAI APILLM APIExperimentsOpenAI
Anthropic APILLM APIExperimentsAnthropic
SupabaseVector store / BaaSExploringSupabase
GitHub ActionsCI/CDSmall deploysGitHub Actions

Role Comparison: AI Automation Engineer vs. Adjacent Roles

DimensionAI Automation EngineerML EngineerBackend EngineerData Engineer
Primary focusLLM integrations, agent workflows, automationModel training, fine-tuning, ML pipelinesAPIs, databases, server logicData pipelines, ETL, warehousing
Core languagesPython, JavaScriptPython, RPython, JavaScript, GoPython, SQL, Scala
Key frameworksLangChain, FastAPI, OllamaPyTorch, TensorFlow, scikit-learnExpress, FastAPI, DjangoAirflow, dbt, Spark
AI involvementHigh — API integration and orchestrationHigh — model building and trainingLow — may consume AI APIsLow — data prep for ML teams
InfrastructureLocal models, API calls, vector storesGPU clusters, training pipelinesServers, databases, cachesData warehouses, lakes
Typical deliverableWorking AI feature or automation scriptTrained model with metricsDeployed API serviceData pipeline or warehouse
My current levelLocal experiments, documented promptsNot pursuingSmall deployed APIsNot pursuing

Expanded Process Notes

How I approach an AI automation project

  1. Define the problem in plain language — Write down what the automation or AI feature should accomplish and what a successful output looks like.
  2. Choose local vs. API — For prototyping, I use Ollama to run models locally for zero-cost iteration. For quality-critical outputs, I test against OpenAI or Anthropic APIs.
  3. Build the backend scaffold — I use FastAPI because it provides automatic request validation, typed responses, and generated OpenAPI documentation (Source).
  4. Document prompts as artifacts — Each prompt is stored with its version, inputs, expected output, and manual review notes in the repository README.
  5. Add evaluation checkpoints — Before shipping, I run manual evaluation passes to check for hallucinations, off-topic responses, and format violations.
  6. Disclose AI assistance — Any code drafted by AI tools is labeled in the README with the prompt used and the edits I made manually.

Common pitfalls I have encountered

  • Hallucinated API calls: LLMs sometimes generate plausible-looking but non-existent library functions. Manual review of generated code is mandatory (Source).
  • Cold start latency: Free-tier hosting (e.g., Render) can take several minutes to wake up, which breaks chat workflows. Documenting this in the README sets correct expectations.
  • Token cost surprises: Without explicit token limits, long conversations can exceed free-tier API quotas. Setting max_tokens and truncating context is essential (Source).

References