Seven AI applications. An agentic marketing platform, and six agent apps on one secure platform — deployed on AWS and Azure.

Traditional vs AI

STAR outcome

SSituation

Two products launching with no marketing staff and a very small budget; the work either didn't happen or came from unverified one-off chat answers.

TTask

Run dozens of marketing and sales jobs automatically, with structured verifiable output, bounded AI cost, and a human gate on everything that leaves — portable from a laptop to a server without rework.

AAction

I designed and built the platform end to end: AI agents that run on a schedule or when something happens in the business, every result checked before it is used, and a person approving anything before it goes out. I tracked what the AI actually cost and brought it well within budget, packaged it to run the same way on any server, and set up automated checks on every change.

RResult

• 42 AI assistants built, covering content, finding leads, sales support and strategy.
• Researching one competitor now costs 31 cents instead of $12.69 — about 41 times cheaper — with every result still checked.
• 27 of them passed full real-world trial runs with no failures; the rest are ready and waiting for real business information.
• Not measured extra revenue or leads — no live campaigns yet.

Traditional vs AI

STAR outcome

SSituation

Security signals are spread across code, dependency, container, cloud and log tools; correlation and response drafting are manual.

TTask

Correlate them into prioritised incidents with evidence and draft a response — without the system acting on its own or an AI inventing findings.

AAction

I built a multi-agent app orchestrated by LangGraph that pulls together warnings from several security tools, backs its analysis with trusted reference material, and waits for a person's approval before any response goes out. I packaged it to run the same way anywhere and set up automated build and deployment, with a manual approval step before anything goes live.

RResult

• In a trial run it turned 37 separate security warnings into 25 ranked problems, most urgent first.
• Recognises all 16 attack types it was designed to spot — this counts coverage, not accuracy.
• More than 600 automated checks run before every release.
• Not measured time saved; trialled on sample data, not a real company's systems.

Screenshots

Sign-insign_in_cybersec.png

New scancybersec_home_page.png

Findingscybersec_findings.png

Ticket previewcybersec_JIRA_ticket.png

Message draftcybersec_slack_message.png

Traditional vs AI

STAR outcome

SSituation

Outage triage over noisy, multi-format logs is manual, and generic AI tools can hallucinate dangerous fix commands.

TTask

Recommend fixes an engineer can trust — auditable, safe, and still working when the databases or the AI provider are down.

AAction

I built a multi-agent app orchestrated by LangGraph that only recommends fixes it can back with evidence and says so when it can't, keeps passwords and keys out of its records, raises tickets and messages only after a person approves, and keeps working when parts of the system are down. I packaged it to run the same way anywhere and set up automated build and deployment, with a manual approval step before anything goes live.

RResult

• In a trial on sample logs it found 34 problems in about 17 seconds, backed every suggested fix with a source, and openly declined the 4 it could not support.
• Working on several problems at once cut one batch from 2½ minutes to under 20 seconds.
• Gives the same answers even when its supporting services are down, and hides any passwords or keys it finds.
• Not measured time saved compared with an engineer doing it by hand.

Screenshots

Sign-upDevOps_Incident_signup.png

OverviewDevOps_Incident_overview.png

Incident detailDevOps_Incident_Details.png

No matching guideDevOps_Incident_AuthenticationFailure.png

PreventionDevOps_Incident_recommendations.png

Dark modeDevOps_Incident_darkmode.png

Sign-in on AzureAzure_IncidentAnalysisLoginIn.png

Incidents on AzureAzure_IncidentAnalysisLoggedIn.png

Traditional vs AI

STAR outcome

SSituation

AI research reports cite sources that don't back them and hide disagreement.

TTask

Build a researcher whose evidence can be checked, and which still works with no model and no databases.

AAction

I built a multi-agent research app orchestrated by LangGraph that checks each claim against its sources and shows where sources disagree instead of hiding it. I packaged it to run the same way anywhere and set up automated build and deployment, with a manual approval step before anything goes live.

RResult

• Fine-tuning cut false alarms about sources contradicting each other from 21 to 9, while the one genuine disagreement always stayed visible.
• Runs live on a server cluster.
• Not measured business impact or accuracy on real-world material — trialled on a small demo library.

Screenshots

First-time setupDeepResearcher_SignUp.png

Sign-in on AzureDeepResearcher_SignIn.png

New investigationDeepResearcher_Start Research.png

Research in progressDeepResearcher_LiveProgress.png

Research completeDeepResearcher_ResearchCompleted.png

Questions it worked throughDeepResearcher_Questions.png

Passages it readDeepResearcher_Contents.png

Every claim scoredDeepResearcher_analysis_2.png

ReportDeepResearcher_Report.png

Traditional vs AI

STAR outcome

SSituation

Automated website tests break whenever a site's look changes, and simple auto-repair tools can make a failing test look like a pass.

TTask

Repair broken tests without ever trading correctness for a pass.

AAction

I built a multi-agent app orchestrated by LangGraph that repairs broken automated test steps on its own, double-checks every repair, and may only visit approved websites. I packaged it to run the same way anywhere and set up automated build and deployment, with a manual approval step before anything goes live.

RResult

• In the demo it fixes broken test steps by itself — in both a simulated and a real web browser, even when its supporting services are down.
• Caught a release that claimed to be healthy but could not actually open a browser; releases are now checked for this automatically.
• Not measured how often repairs succeed, or time saved, on real websites.

Screenshots

Sign-in on AzureUIAutomation_Login.png

Generated test scriptUIAutomation_CodeGenerator.png

Test runs on AzureUIAutomation_Run.png

Verified repairsUIAutomation_UpdatingNewSelector.png

Dark modeUIAutomation_DarkMode.png

Traditional vs AI

STAR outcome

SSituation

Design and accessibility review is manual and subjective, and AI critique tools invent measurements.

TTask

Build a reviewer whose numbers are checkable and which still works without an AI key or databases.

AAction

I built a multi-agent app orchestrated by LangGraph that reviews designs against measurable checks, explains what it finds in plain language, and keeps working even without its AI service. I packaged it to run the same way anywhere and set up automated build and deployment, with a manual approval step before anything goes live.

RResult

• Clearly tells good designs from flawed ones: good samples score 96–98 out of 100, flawed ones 55–72.
• Removing repeated findings shortened one report from 30 items to 21.
• Repeat reviews of the same design came back in under a second instead of 11 seconds.
• Not measured review time saved, or how well it agrees with human reviewers.

Screenshots

Sign-in on AzureDesignAnalysis_Login.png

Upload and reviewDesignAnalysis_Upload.png

What to fix firstDesignAnalysis_Analyze.png

Compare two designsDesignAnalysis_Compare.png

Comparison resultDesignAnalysis_CompareResults.png

Dark modeDesignAnalysis_DarkMode.png

Traditional vs AI

STAR outcome

SSituation

Personal finances live in messy, inconsistent bank exports; tools either chart without deciding, or use AI that can hallucinate numbers.

TTask

Build a coach whose figures are exact and traceable, and which keeps working with no AI key and no databases.

AAction

I built a multi-agent personal-finance coach orchestrated by LangGraph with exact money calculations, automatic sorting of spending into categories, and each person's data kept separate. I packaged it to run the same way anywhere, with one-step deployment.

RResult

• Sorted all 234 transactions in a demo account into spending categories, with none left unsorted.
• For a demo household its debt plan paid everything off 39 months sooner and saved £4,977.79 in interest compared with paying only the minimum (made-up data).
• Keeps working even when its supporting services are down.
• Not measured how many people use it, time saved, or accuracy for real households.

Screenshots

Sign-inAI_Financial_coach_signin.png

OverviewAI_Financial_coach_overview.png

Category vs guidelineAI_Financial_coach_categorization.png

BudgetAI_Financial_coach_budget.png

RecommendationsAI_Financial_coach_ecommendations.png

TransactionsAI_Financial_coach_transactions.png

AskAI_Financial_coach_QnA.png

Traditional vs this build

STAR outcome

SSituation

Each of my applications kept its own figures in its own database. There was no shared warehouse, no single agreed definition of a number, and no way to prove a published total still matched the source it came from.

TTask

Build a warehouse pipeline where every published number is tested before it is published, where a bad input stops the run instead of quietly producing a wrong report, and where the schedule needs no extra orchestration tool.

AAction

I built raw, cleaned and reporting layers on Snowflake using dbt, with dbt running inside the warehouse and triggered by Snowflake's own two-step task graph. Every data test runs at error severity, so one failure fails the build, fails the task and skips everything downstream — including the reconciliation test that compares money totals between layers. I added plain-English questions over the reporting tables, a dashboard, per-household row-level access, spending caps, and a build pipeline in which every check must prove it actually examined something before it is allowed to report success.

RResult

• Loaded 2,708 transactions, 101,178 log lines and 26 incidents in 8 seconds, with the full transformation finishing in 44 seconds inside Snowflake.
• A load with 6 deliberately planted defects failed with exactly those 6 test failures and every reporting table was skipped, so the last good version stayed in place.
• 89 data tests gate every run. Pull-request checks add unit tests, a full-history secrets scan, and floors that fail any check which looked at nothing.
• Runs unattended on a daily schedule; one run metered at 0.055 Snowflake credits, under a monthly cap that suspends the warehouse when reached.
• Not measured anything on real customer data — the source files are synthetic, generated from a fixed seed.

Screenshots

Traditional vs this build

STAR outcome

SSituation

The Snowflake build proved the pipeline, but it covered none of the machine-learning lifecycle, and the figures it produced had no route back to the application that people actually use.

TTask

Rebuild the same pipeline on a second platform without reusing its transformation tool, add the model lifecycle and the path back to the app, and make every claim about correctness and about permissions something a run can demonstrate rather than something a document asserts.

AAction

I rebuilt the cleaned and reporting layers in PySpark under Unity Catalog governance, with the whole job graph, its schedule and its dashboard defined in one code file and run on compute the vendor manages. The quality gates set rejected rows aside with their reasons and hold a reconciliation gate that compares money totals exactly. I fine-tuned a DistilBERT text classifier over 22 spending categories, recorded every run, versioned the model in the catalogue behind an evaluation gate, and served it as a shared service used only after a rules layer and only when it is at least 80% confident. A scheduled Kubernetes job copies the summary figures into the application's own PostgreSQL through a login confined to one schema and two tables.

RResult

• The two platforms agree on all 12 reporting tables — identical row counts and the same money totals to the penny, from the same input files.
• Proved with a deliberately corrupt batch, not only a clean one: the gate failed and every later step was skipped, so nothing wrong was published.
• The classifier chain — rules first, then the model only at 80% confidence or above, then closest-match on meaning — raised agreement with 245 reviewed labels from 95.5% with 9 wrong answers to 99.2% with none.
• The first copy back into the app's database moved 780 rows in 36 seconds, and eleven checks each prove one thing that login is refused rather than asserting its permissions.
• Not measured accuracy on real bank data — the data is synthetic, and those 245 labels were reviewed by me rather than independently produced. The drift monitoring raises an alert; it does not stop a run.

Screenshots

The cluster and its supporting services

Kubernetes clusterAWS_EKS_cluster.png

Separate spacesAWS_kubectl_NameSpace.png

Entry pointAWS_k8s_LB.png

Load balancerAWS_k8s_LoadBalancer.png

Spread across data centresAWS_k8s_loadbalancer_networkmapping.png

Web addressesAWS_Route53_HostedZones.png

HTTPS certificatesAWS_TLS_Certificates.png

Secrets delivered safelyAWS_k8s_ExternalSecrets.png

Secrets storeAWS_SecretManager.png

Private image storeAWS_ECR_registry_images.png

DatabaseAWS_Aurora_and_RDS.png

CacheAWS_ElasticCache_Redis.png

Cache copiesAWS_ElasticCache_Redis_nodes.png

File storageAWS_S3.png

Monitoring & observability

App monitoringAWS_CloudWatch_k8s_Monitoring.png

Database monitoringCloudWatch_Database_Monitoring.png

Database loadAWS_DB_monitoring.png

Job logsAWS_CloudWatch_LogEvents.png

Log searchAWS_CloudWatchLog_Query.png

AI usage trackingAWS_Langfuse_modelUsage.png

AI response timesAWS_Langfuse_Latencies.png

AI run historyAWS_k8s_LangFuse.png

Security

Audit trailAWS_CloudTrail.png

Threat detectionAWS_GaurdDuty.png

The three flows

Secure website. Pages come from private storage, and sign-in is checked twice — before the page loads and again on every request to the app.

Scheduled jobs. Jobs run automatically on a timetable, each in its own locked-down space.

Upload-triggered jobs. Uploading a file starts an analysis automatically, and a report is saved when it finishes.

Screenshots

Private web deliveryAWS_CloudFront.png

Locked-down storageAWS_S3_BucketPolicy.png

Sign-in checkAWS_Lambda_At_Edge.png

Sign-in firstAWS_LamdaAtEdgeLogin.png

Serverless functionsAWS_Lambda_Functions.png

Protected APIAWS_API_Gateway.png

Request routingAWS_API_Gateway_with_Lambda.png

Background jobsAWS_ECS_Tasks.png

Job historyAWS_ECS_Batch_Task.png

Job reportsAWS_S3_output_after_BatchJob.png

Job logAWS_ECS_Task_Logs.png

Access enforcedError_codes.png

The cluster and its supporting services

Resource groupaz_resource_groups.png

Kubernetes clusteraz_aks-cluster.png

Cluster securityaz_cluster_security_configuration.png

Private image storeaz_container_registry.png

Entry point and HTTPSaz_load balancer and cert-manager.png

Web addressesaz_public_dns zone.png

Private addressesaz_private dns zone.png

Secrets storeaz_key_vault_secrets.png

Secrets delivered safelyaz_external_secrets.png

Databaseaz_database for postgres flexible server.png

Private databaseaz_DB_Private DNS and VNet.png

Cacheredis.png

Monitoring, audit & cost

Cluster monitoringaz_aks_cluster_monitor_insights.png

Network dashboardaz_grafana_monitoring.png

Database monitoringaz_database_insights.png

Cache monitoringaz_redis_monitoring.png

Audit trailaz_monitor_activitylog.png

Cost trackingCost Mgmt_Cost analysis.png

The serverless flows

Scheduled jobs. A security scan runs every morning on its own, in a job that exists only while it runs.

Upload-triggered jobs. Uploading a log file starts an incident analysis automatically, and the result is saved when it finishes.

Pay-per-use functions. Small functions handle requests and start jobs, and cost nothing while idle.

Serverless functionsFunction App.png

File uploadaz_upload in blob storage.png

Upload eventEventGrid_Event.png

Job starterFunction App_code.png

Background jobsContainer App jobs.png

Scheduled runsContainer Apps Job_Exec History.png

Job logsLog Analytics Workspace Logs.png

Request traceApplication insight log.png

Function healthApplication insight metrics.png