dansabin.com

The site you are on, a resume you can question, and a reference architecture for cloud infrastructure, with an agent built from AWS primitives rather than a collection of SaaS products.

case study · 2026
~/dansabin.com — chat Ask about this project

What it is

dansabin.com is an interactive resume. A recruiter, hiring manager or potential client arrives with no account, reads about my experience and work, and then questions an AI that speaks as me, at any hour and without me present, to decide whether I fit their need.

A visit should end in an assessment and, when there is a fit, in a message to me. The form in the chat and on the home page reaches me. I read everything and reply when I can, by email. Your message reaches me as an email built with inline-email, my own library, and delivered through SES, so the email I quote in my reply shows you that template in action.

The site is also its own proof. The chatbot, its hosting and its safeguards are built on AWS by me, so exploring the site is exploring the work.

What a resume leaves out

A resume is my interpretation of what I think people need to see. Jobs have unique demands, and I can't tailor a resume for every possible scenario. A visitor with their own engineering requirements may want to assess my experience as it applies to them, not as I've presented it chronologically. Things I did early in my career are still learnings I have. They may be the ones that apply to you, and they compound with everything after them.

A resume is more of a traditional index. The site, my learnings and the posts here are a better measure of my expertise, but they take a person reading all of them. The agent is there to draw attention to the expertise that fits what you're asking. It's more of a customer service experience.

How it's built

The parts a visitor meets, and what travels between them The visitor's browser reaches CloudFront for the pages and the window, and AWS WAF's human check and rate rule for a question. The question goes on to the chat function, a Lambda Function URL with the Strands agent inside it, which calls Claude Sonnet 4.6 and Nova 2 Lite on Bedrock, searches the Knowledge Base built from my Markdown files, saves the conversation in DynamoDB and S3, and streams the reply back. A message from the form in the chat or on the home page takes its own path, through a queue and SES, as an email to me. CDK and CI deploy all of it. The regions are drawn as one box; Multi-region shows the two. VISITOR visitor browser EDGE CloudFront pages and the window AWS WAF human check, rate rule queue and SES an email to me TWO REGIONS, SEE MULTI-REGION chat function Lambda Function URL Strands agent inside Bedrock Claude Sonnet 4.6 Nova 2 Lite Knowledge Base Markdown files DynamoDB and S3 conversations pages question message question reply, streamed question reply files saved CDK and CI GitHub Actions, OpenID Connect deploy The parts a visitor meets, and what travels between them The visitor's browser reaches CloudFront for the pages and the window, and AWS WAF's human check and rate rule for a question. The question goes on to the chat function, a Lambda Function URL with the Strands agent inside it, which calls Claude Sonnet 4.6 and Nova 2 Lite on Bedrock, searches the Knowledge Base built from my Markdown files, saves the conversation in DynamoDB and S3, and streams the reply back. A message from the form in the chat or on the home page takes its own path, through a queue and SES, as an email to me. CDK and CI deploy all of it. The regions are drawn as one box; Multi-region shows the two. visitor browser pages question EDGE CloudFront pages, the window AWS WAF human check, rate rule question TWO REGIONS, SEE MULTI-REGION chat function Lambda Function URL Strands agent inside Bedrock Claude Sonnet 4.6, Nova 2 Lite question and reply Knowledge Base Markdown files, retrieved at run time DynamoDB and S3 conversations, saved per visitor the reply streams back to the visitor A MESSAGE TO ME queue and SES the form, an email to me DEPLOYS ALL OF IT CDK and CI GitHub Actions, OpenID Connect
The parts a visitor meets, in order. Pages and the window come from CloudFront. A question passes the human check and rate rule at the edge, then reaches the chat function, where the agent calls Claude and Nova on Bedrock, reads the Knowledge files and saves the chat, and the reply streams back. A message from the form in the chat or on the home page takes its own path to me. CDK and CI deploy everything. The regions are one box here; Multi-region draws the two.

Seven pages go deeper:

The agent. How a question becomes an answer, and how the agent is kept honest.

Search. Why the agent once couldn't find my resume, and why I fixed search before the button.

Multi-region design. How the API runs in two regions, how the edge picks one for each request, and what happens when one fails.

CI/CD: from pull request to production. How a pull request gets its own live copy of the site, how a push to main reaches prod, and the infrastructure as code behind both.

Cost and abuse. What stops someone running up my AWS bill.

A visitor with no account. How a chat stays yours with no login.

Testing. Why I cut tests when an AI can write as many as I want.

Decisions

The human check is there to protect a bill and to stop spam. AWS WAF CAPTCHA is the one-time check, and a rate rule blocks floods at the edge before any function runs. WAF and CloudFront are optimizations for bad actors. Before I settled on them I looked at building my own, including an ants on tv static CAPTCHA and a quick top-down racing game, but what's built into CloudFront would work, and I could deploy WAF.

The Knowledge is indexed into a Bedrock Knowledge Base and retrieved at run time with semantic queries, so the prompt stays small as the material grows. On a question about me, code runs the search rather than the model. In tests, asking the model to search worked 18 times out of 39, and forcing the search worked 42 times out of 42. On a greeting or an off-topic message, the writer keeps a search tool it can use for itself.

Every turn is metered in model tokens against a per-visitor and a whole-site bucket. Replies get shorter as a budget runs low, and a turn is refused only when the budget cannot cover it, with the time it refills shown. I wanted a visitor on reduced capacity to see and understand that, rather than judge the agent as limited in depth.

A visitor has no login, so I had to ask how we'd stop people stealing or hijacking each other's chats without a user and password, and then how hard it would be to keep a secret in the browser. So the browser holds a key it can use but can't carry away, and every request carries a proof signed by that key.

What it gave up: a chat belongs to that browser. If the browser loses the key, the visitor passes the human check again and gets a new identity, and earlier chats can't be opened again. A private window's chats end when it closes.

Results

There are no visitor numbers to report yet. What I can give you was measured before real visitors arrived:

  • A chat turn: about 2 cents for a typical one, from 52 turns on production over 14 days. About 8 cents is the ceiling a long conversation can reach.
  • First words: about 3.0 seconds, the median in a test of 12 hard questions run three times each.
  • Failover: rehearsals moved traffic to the other region in 2 minutes 20 seconds to 3 minutes 56 seconds, on non-production copies, depending on how the region was broken.

What it is built from

  • Infrastructure as code. Everything is AWS CDK in TypeScript, in one AWS account across us-east-1 and us-west-2, with Jest tests on every stack's template and a coverage gate. A pre-push git hook runs the typecheck and the tests before any push.
  • DNS. One Route 53 hosted zone for dansabin.com, in its own stack, which is termination-protected and retained, so destroying an environment can never take the domain down. The domain stays registered at GoDaddy with its nameservers pointed at Route 53.
  • Hosting. Pages are served from private S3 buckets through CloudFront with origin access control, with their own ACM certificate validated by DNS and a real 404 page. A multi-region environment holds them in a bucket in each region. One deploy writes both, and CloudFront fails over between them per request.
  • The API edge. The API is its own stack and its own CloudFront distribution on api.dansabin.com.
  • Environments. Every environment is the same set of stacks, named by a suffix: prod, a personal one per developer, and one per pull request. Each has its own hostnames, buckets and distributions under the shared zone, for example pr-12.dev.www.dansabin.com.
  • CI and CD. GitHub Actions authenticates to AWS through OpenID Connect, with no stored AWS keys. The deploy role trusts only GitHub's immutable subject for this repository and may assume only the roles CDK bootstrap created, with read access to stack outputs and test-run access to the routing functions. Opening a pull request deploys a live copy of the site and API and comments the URLs on the pull request; closing it destroys that copy; a push to main deploys prod.
  • Operations. A Makefile is the single entry point: SSO login, synth, diff and deploy per environment, destroy for a personal one, a DNS readiness guard that every deploy runs first, and a read-only inventory of the account that spots manually created resources, checks stack health and shows the month's cost.
  • The model and the agent. A small Amazon Nova 2 Lite call decides whether to search and plans from the search results, and a Strands agent on Claude Sonnet 4.6 writes the reply, on Amazon Bedrock, streaming it to the browser from a Lambda Function URL. It speaks in the first person as me, grounds every fact about me in files kept in this repository, says when it does not know, and leaves reserved topics such as salary to me.
  • The Knowledge. Plain Markdown files in the repository, reviewed and versioned like code, starting from my own words and my resume.
  • Keeping bots out. Passing the human check gives the visitor an anonymous signed identity, with no account and no name required, from keys that rotate every 14 days.
  • Keeping cost bounded. The token buckets above, and an AWS Budget with alerts that trips a kill switch, which stops new turns while the site keeps serving.
  • Conversations. Saved per visitor in DynamoDB and S3, paged, and deleted after 1 year without a visit or on request.
  • Getting in touch. A form in the chat and on the home page. It goes through a queue and SES, to me only, and pressing Reply answers the person.
  • Resilience. The API runs in two regions, us-east-1 and us-west-2, and pages are served worldwide through CloudFront. The edge picks the region per request from health flags in a CloudFront KeyValueStore, and when a region fails its health check, visitors go to the other.
  • Privacy. A privacy notice, AI disclosure in the chat, no IP addresses stored with conversations, and deletion on request.

What it demonstrates

  • Designing on AWS for a real constraint, a personal budget, with the trade-offs written down: why WAF CAPTCHA rather than a third-party check, why a Knowledge Base rather than everything in the prompt, why token buckets rather than counting messages.
  • Infrastructure that is safe to change: every pull request gets its own live environment, a push to main deploys prod, and I can also deploy prod by hand. Destroying an environment removes only that environment's stacks, and the domain's hosted zone lives in its own retained stack.
  • Security by default: no long-lived AWS keys in CI, a least-privilege deploy role, private buckets behind CloudFront, and functions reachable only through the edge.
  • The way I work, end to end: requirements, then a design, then tasks, then tested code, each step reviewed before the next.

Why I built it this way

In my words: dansabin.com is an example of almost all of the skills I've learned as an engineer wrapped into a single product. As a service, the infrastructure leverages learnings from all of the services I have worked on in the past:

  • The way developers can create parallel ephemeral environments, and how pull requests can deploy and test against their own ephemeral environments.
  • The importance of unit tests and coverage, then integration tests and pre-production testing, the automated rollbacks, alarms, and other monitoring.
  • The CI/CD pipeline that automates deploys and operational actions.
  • The two-region architecture: the edge picks the region per request from health flags, and when a region fails its health check, visitors go to the other. One global table spans the regions and the transcript buckets replicate.
  • the serverless design and autoscaling that matches demand so cost is always appropriate.
  • The use of various storage layers like S3 and DDB, so that the size, shape and access patterns of the data are all considered when laying out the storage architecture.

It's a culmination of all of my expertise, including now how the agents collaborate and how that manifests itself in the user experience.

Who built it

I built the site. Agents are tools, period. Asking an agent to build this would have produced a very messy single folder full of long files, with no models and no reusable, testable or extensible code. The automated CDK propositions would have had the same issues. Agents lack the finesse to think about how things can be built to scale or expand later. They don't understand what they're building, because they don't understand why they're building it.

In the end an agent may have typed the code, but an agent couldn't have built the site, because it doesn't even understand that the site exists or what its purpose is. It can be instructed to explain these things, which is why there are knowledge files and context. Those files are the reasoning, and they're also the expertise that decides how failover is best implemented or how everything is laid out. Agents can't make those decisions, and if you let them, they'll make them incorrectly.

What I'd do differently

The site is complex. I could have made it simpler, done less, and shipped a product that looked like this but was held together behind the scenes by glue and services. But this site was more a test: did I remember everything I'd learned in my career? Did I recall the testing practices, the security designs, the product considerations and the cost optimizations?

Arguably the only thing I would have changed is building it sooner, so that there was more to the story than the punchline. The site now stands as a symbol of my expertise, but it's delivered as one work, all at once, at a time when AI can take credit for the work. It could just as easily have been built over time, with commits made before AI was real, when it was clear that no one else could have written it but me.

Questions I get about it

Why build a reference architecture as a personal site?

As a personal site, it's over-engineered. As a tech demo in the portfolio of someone with a 15-year career, it's a concrete example of what I've learned, with stories from real work at real companies behind each feature I've built. It comes off as over-engineered, but it's more of a reference architecture for cloud-based infrastructure. It could be used by many kinds of business, now including agentic features built from primitives rather than a collection of SaaS products.

Why Bedrock?

I want to show how this runs just above bare metal in the cloud. Claude writes the replies, but it isn't the whole design. I use Nova for model work where I can, and I use Claude for its ability to sound more human. That seemed worth the cost, and it's something I can still tune or adjust. With a raw Claude key I'd be tied to that one approach, with fewer levers. Here, no model key exists: the function's role can call two inference profiles and search one Knowledge Base.

What does a chat cost?

About 2 cents for a typical turn, from 52 turns on production over 14 days. About 8 cents is the ceiling a long conversation can reach: 7 cents of that is the context sent to Sonnet, the reply itself is under a cent, and the Nova calls are fractions of a cent. Real visitors will change the typical number, because they haven't arrived yet.

With nobody here, it scales to 0 minus trivial hosting fees. It costs less than a tank of gas.

What does a spec look like when you write one?

Each step of this site was written up as a spec first. "Spec-driven development", another file in this Knowledge, walks through a real one from this repository.

How do you test a change before it ships?

Ephemeral testing on the lines, then unit testing, then browser-based behavior testing using my own custom harness.

Ephemeral testing on the lines is a scratch script that exercises the new lines of a change and is deleted before the change is done. The unit tests are the ones the pre-push hook runs, and the harness is my test harness project. Testing has more.

How does a change get to the live site?

Full CI/CD, ephemeral PR environments, then automated deploys and smoke tests.

"CI and CD" above has the steps: a pull request deploys its own live copy, and a push to main deploys prod. The smoke tests then run against prod.

How does it know who a visitor is without an account?

A visitor who passes the human check gets an anonymous signed identity, with no account and no name required, and the browser proves it holds the device key on every request. The human check is there to save tokens for real people.

What else did you do to keep the AWS side secure?

Secrets management, AI safeguards, and AWS best practices like least privilege.

"What it demonstrates" above has examples: no long-lived AWS keys in CI, a least-privilege deploy role, and private buckets behind CloudFront.

Secrets management means my secrets live in AWS Secrets Manager, not in the repository: the keys that sign a visitor's anonymous identity, which rotate on their own, and the password for the gate in front of an environment, which AWS generates. Each secret is readable only by what needs it, and CI signs in through OpenID Connect rather than holding AWS keys.

AI safeguards means the agent is grounded in what I wrote. Every fact about me has to come from my Knowledge, and when it isn't there the agent says it doesn't know and offers a way to reach me. It stays in character and doesn't take new instructions from a visitor, and a note a visitor writes in a Project counts as their context, never as my rules or as a fact about me. Topics I keep for myself, such as salary, it leaves to me. The chat says up front that it's an AI, and the agent says so when asked. On a question about me, code runs the search and the writer gets no tools. On a greeting or an off-topic message, the writer can search my Knowledge and read today's date. Neither changes anything in my AWS account. Those tools and the token budgets above are enforced in code; the rest are instructions the model follows.

Why serverless for something like this?

I'm not that popular. If things get busy, it scales to meet demand. With nobody here, there are no servers to keep up, and it scales to 0 minus trivial hosting fees.

Want the details?

Ask the window anything this page skips.