Steven Gorrell

Tickets that pass between several departments get long, and engineers were spending too much time reading them before they could start diagnosing. This assistant lives inside the ticketing system: it takes ticket data in real time, runs automated analysis against existing cloud infrastructure, knowledge bases and other supporting APIs, and sends the results to AWS Bedrock, with custom MCP servers for context. Engineers get a compact summary that is regenerated on every ticket update, so it is never stale, plus suggested troubleshooting steps with a confidence score, and remediation scripts or code patches where appropriate.

• Cuts ticket handling time, and is designed to help newer engineers resolve tickets without escalating.
• LangGraph pipeline that presents data to AI "personas" prompted for engineering and software development.
• DynamoDB caching layer.
• React frontend.
• Python MCP servers.
• AWS Bedrock, OpenSearch, APIs, and MCP servers give the LLM context.
• End users are presented with actionable solutions.

• AWS Bedrock
• LangGraph
• Python
• DynamoDB
• OpenSearch
• API Gateway
• React
• Terraform
• Vite

Support engineers were spending their shifts running the same diagnostic steps against recurring cloud resource alarms. This service intercepts the monitoring event stream, filters noise, and hands qualifying alarms to Lambda backed Step Function workflows that execute diagnostic and remediation automation against effected resources. After running it provides the engineer with a detailed analysis of findings and fixes performed.

• Per-alarm handlers covering compute, database, load balancer, backup, VPN and DNS conditions.
• Filtering keeps invocation cost proportional to actionable events rather than total event volume.
• Catch-all exception handling on every branch: a failure still produces an event, so nothing is silently dropped.
• Extended to Google Cloud, where a single remediation absorbed a significant share of incoming alarm volume; later extended to private cloud through AWS Systems Manager, collecting diagnostics into the ticket before an engineer logs in, taking a public-cloud tool company-wide.
• Runs hundreds of thousands of automated actions a year, saving thousands of estimated support hours.

• Python
• AWS Step Functions
• Lambda
• AWS Systems Manager
• DynamoDB
• AWS SQS
• ElasticCache
• Terraform

A platform for deploying standardized configurations and monitoring tooling across a managed fleet spanning multiple cloud vendors. A product catalogue defines what can be deployed; a versioned REST API and worker fleet handle deployment, update and removal; every request lands in an Athena-queryable audit log. Every onboarded customer gets the required support tooling, IAM roles and storage standards automatically, so engineers can start work immediately with no manual setup. It was built before AWS Control Tower and Organizations existed, and works for customers who use neither.

• Lambda-router API behind API Gateway with a custom authorizer and published OpenAPI documentation.
• Athena schemas over structured request logs, so auditing a change is a simple SQL query.
• React for end user interaction.
• A large, versioned catalogue of supported automations.

• Python
• API Gateway
• Lambda
• DynamoDB
• Athena
• React
• TypeScript
• Vite
• Terraform

Planned maintenance used to page engineers and open tickets for alarms everyone already expected. This product lets support teams suppress alerts and tickets for a defined window, through an API and a React front end that replaced a workflow only reachable by sending API calls from code. It keeps false-alarm tickets out of support queues, so engineers no longer spend time investigating alarms only to find they were caused by planned maintenance. Every onboarded AWS and Google Cloud customer is enrolled automatically.

• Serverless API with a React and TypeScript front end for support engineers.
• Automatic enrollment of onboarded customers, so coverage never depends on someone remembering to opt in.
• Rebuilt on React and Vite with shared single sign-on session handling, which made it significantly faster to load, and deployed through Terraform and GitHub Actions.
• Integrated as a micro-frontend in the customer portal.

• Python
• API Gateway
• Lambda
• DynamoDB
• React
• TypeScript
• Vite
• Terraform

PCI-regulated environments must prove that every privileged API call was expected. This service evaluates an environment's control-plane event stream against a declarative ruleset of authorized principal, action and resource combinations. Anomalies are alerted on and recorded in real time, and a daily pull request of only the exceptions lets the team meet PCI's daily log-review requirement without hunting through the full logs.

• Declarative ruleset keyed on principal, action and target resource — reviewable as code.
• Deployment pipelines are themselves modelled in the ruleset, so automated infrastructure changes are analyzed.
• Fail-open-to-alert design: any processing exception emits an unexpected-event record rather than losing the event.
• Provides assessors with an immutable, timestamped, reviewed trail.

• Python
• CloudTrail
• CloudWatch Events
• DynamoDB
• Lambda
• PCI DSS
• Kinesis
• Splunk
• Terraform
• Vite

Answering "what is actually running in this customer's cloud, and is it configured the way we recommend?" was a multi-day manual exercise. This tool automated it: a parser expands the request, agents collect inventory and configuration across accounts, results are processed asynchronously with progress tracking, and the output is rendered as a spreadsheet or published straight to the internal wiki. Built first for AWS, then extended to Google Cloud.

• Asynchronous job model with progress reporting, so long-running scans don't hold a request open.
• Agent-based collection via Systems Manager rather than requiring inbound network access.
• Pluggable output writers — Excel for customers, JSON, wiki markup for internal review.
• Parallel AWS and GCP implementations sharing the job and reporting model.

• Python
• AWS API Gateway
• AWS Systems Manager
• Lambda
• AWS S3
• AWS SQS
• Step Functions
• Terraform
• Vite

Giving an AI assistant useful access to cloud tooling is mostly an authorization problem, not a prompting one. I built the internal AWS tooling API and the Model Context Protocol server that fronts it, backed by Amazon Bedrock models and exposing resource lookup, configuration diffing and instance inspection as MCP tools, so support engineers can troubleshoot customer environments with an assistant that surfaces recent activity relevant to the issue and suggests next steps, shortening investigations. A second server connects configuration, inventory and ticketing data to a LangGraph solution that removes most of the manual data gathering before customer business reviews, and preps account managers with feedback from CEO, CFO and lead-architect personas. The same server also powers the ticketing assistant described above.

• Customer-level access controls enforced on the server side rather than left to the model.
• Tool surface deliberately narrow and read-oriented — capability granted by design, not by prompt instruction.
• Deployed as infrastructure-as-code alongside the API it wraps.

• Python
• Model Context Protocol
• AWS Bedrock
• LangGraph
• FastAPI
• Poetry
• Terraform
• LLM tooling

Replaced spreadsheet pivot tables and Power BI reports with a single view that the C-suite now uses in its weekly decision-making meeting. Data engineering for leadership reporting on the Palantir Foundry platform: Python transforms that shape CRM, ticketing and revenue data, TypeScript server-side functions that compute the metrics, and React front ends built with Vite and Recharts that turn them into revenue-trend and monthly business-review dashboards. Also built the streaming transforms that feed support-automation events into the platform's ontology, and the functions behind its capacity-planning views.

• KPIs feed LLMs through metric-specific prompts that generate plain-language interpretations alongside the charts.
• Transform layer separates raw ingestion from the metric definitions consumed by dashboards.
• Server-side TypeScript functions keep metric logic in one place across dashboards and applications.
• Front ends built against a shared internal design system for consistency with other tools.

• Python
• TypeScript
• React
• Vite
• Recharts
• Palantir Foundry
• Kinesis