AWS Builder Center
Full Stack Challenge: ShadowLog

Full Stack Challenge: ShadowLog

I built ShadowLog a wellness app that tells people they're burning out before they do, then deployed the whole AWS backend from a CloudShell tab, no local AWS setup required

Solutions Architect
What if the people on your team could catch their own burnout weeks before it costs you them?
I built a wellness application a leader can offer their team, built around a problem that shows up on no HR dashboard: the exact moment a valuable person starts to burn out, weeks before they decide to quit. I called it ShadowLog, and the principle behind it is simple — every meeting, every task, every conversation leaves a trace of energy, not just of time. A five-second log after each event, with a score from one to ten, builds within a few weeks a map that no annual climate survey can capture: which activities, which meetings, which specific patterns systematically drain a person before that wear translates into a resignation. Each person's map belongs only to them, with no manager view and no team dashboard. That privacy is what lets a leader offer the practice as a genuine benefit, and what makes people trust the log enough to be honest in it.
Leaders do care about their team's burnout. The harder truth is that the person experiencing it often doesn't notice it either, until it's already a resignation — and no dashboard, however sophisticated, could surface something the person themselves hasn't recognized yet.
Who it's for and what it solves
ShadowLog is a private wellness practice a leader can offer their team, with no manager view of anyone's data, by design: each person with a calendar full of commitments they accept without noticing the cost, knowledge workers, caregivers, people who chain client meetings back to back, gets a five-second way to see their own pattern before it turns into a resignation. What it solves is energy awareness rather than time management, and what it creates for a leader is a team culture where people notice their own decline early enough to say something, instead of quietly checking out. Most cases of burnout build quietly, as an eclipse over weeks, without anyone noticing.
If three consecutive logs show a downward trend, ShadowLog doesn't wait for a clinical diagnosis of exhaustion. It surfaces, discreetly, a brief, non-clinical reflection, optionally generated by a foundation model through Amazon Bedrock.
Full stack breakdown: from pitch to launch
Pitch. Engagement surveys reach leaders once or twice a year, far too late to act on, while the cost of losing a key person is already budgeted for in most boardrooms. The gap between those two facts was the starting point: give each person on a team their own five-second signal, long before any survey or exit interview would catch it.
Prototype. Before any AWS service entered the picture, the prototype's only job was proving the core idea actually works: a real declining trend in someone's energy has to surface as a warning, reliably, before anything else gets built around it.
MVP. The MVP discipline showed up as subtraction. Gamification streaks, social features, and calendar integrations were deliberately left out because they would have added complexity without adding the one signal the product exists to deliver: energy trending down before it becomes a resignation. Three functions — log, report, alert — defined the entire surface area.
UX. The UX bet was that the five-second log, a score, an emoji, a tag, had to be validated before any other piece of the system, because if that friction doesn't disappear completely, nothing built around it matters. The twilight color palette followed the same logic: a moment that's honest and slightly vulnerable needed to feel safe and personal.
Launch. Launch meant every command that touches AWS runs from CloudShell, with none of the heavy lifting — building the Lambda functions, building the frontend — happening there. That constraint pushed authentication to be pluggable from the start, so the same frontend can point at a local dev server or at real Amazon Cognito depending on how it's built.
How I built it
I separated the backend into pure, framework-agnostic business logic — streak detection, weekly aggregation, reflection prompt construction — wrapped in thin adapters around that logic: a set of AWS Lambda functions for production, and an Express server backed by a JSON file for fast local iteration. That separation made it possible to validate the actual product logic — whether a real 8-5-3 sequence triggers the alert, whether the shadow map sorts correctly — against an application running in the same working session, before touching AWS, by registering a user, logging three declining energy pulses, and watching the burnout-streak warning appear exactly when it should.
The most important decision was making the CloudShell side of deployment depend on as little as possible. The CloudFormation template does use the SAM transform for the Lambda functions and the HTTP API, built and deployed without the  sam  CLI tool: the four functions are pre-bundled locally with esbuild into single files, and the deploy scripts run nothing but plain  aws cloudformation package / deploy . That matters because CloudShell is meant to be a deploy shell — it has a limited persistent-storage quota and sessions that can time out, so keeping  npm install / npm run build  off it entirely was deliberate. The real cost is two round trips: build and deploy the backend on your own machine and CloudShell, copy the Cognito/API values it prints into the frontend's build config, then repeat the same build-and-deploy cycle for the frontend. The hardest part was authentication: the frontend needed to work identically against a local JWT server and against real Amazon Cognito, so I abstracted authentication behind a provider interface and swapped implementations via an environment variable at build time.
The architecture on AWS
The database is a single Amazon DynamoDB table, with  PK=USER#<id>  and  SK=LOG#<isoTimestamp>#<id> , so that both recent logs and the weekly report resolve with a single ordered query and no secondary indexes. Four AWS Lambda functions, exposed through Amazon API Gateway in HTTP API mode, are protected by an Amazon Cognito JWT authorizer, which also handles user registration, email confirmation, and sign-in. Amazon Bedrock comes in as an optional, model-agnostic piece, generating the reflection prompt when a burnout streak is detected, with a template-based fallback so the feature keeps working even before enabling access to a specific model. The compiled React application is served from Amazon S3 and Amazon CloudFront, hosted in a private bucket via Origin Access Control.
What this build ended up teaching me
Building the AWS path and the local path in parallel forced the core business logic into pure, dependency-free functions, and that constraint turned out to be the right architecture anyway — the same streak-detection and reporting code runs unchanged in both environments instead of two versions slowly drifting apart. It also confirmed something that applies beyond this project: the less flashy infrastructure decision — keeping the  sam  CLI and Docker out of the loop, packaging with esbuild instead, and deploying with plain  aws cloudformation package / deploy  — is often what actually makes deployment possible from an environment as restricted as CloudShell, even at the cost of two build-and-deploy round trips.
Designing authentication as a pluggable interface before knowing which provider would sit behind it, rather than wiring the frontend directly to Cognito from day one, is what let the same UI run against a local JWT server for fast iteration and against real Cognito for production without a rewrite — a decision that paid for itself the first time login had to work identically in both places.
The cost side taught a related lesson: a "test app" doesn't stay cheap by accident. The hard ceilings in the template — API throttling that caps every Lambda invocation, DynamoDB read/write, and Bedrock call behind it, Lambda functions sized at the platform minimum, and a spend alert set up before the first real deploy — had to be designed in deliberately, the same way the business logic did. Cost safety turned out to be an architecture decision, not an afterthought.
Repository
Anyone who wants to deploy their own instance can clone the repository — the  README.md  at the project root covers everything, including a local-only quick-start with no AWS account needed and the full two-phase deploy through CloudShell.
ShadowLog is a small bet on a simple idea: the earliest, most useful signal of burnout comes from the person living it, in five seconds, before they've even named what's wrong to themselves. Offering it to a team means handing each person a private mirror, and trusting that people who can see their own pattern clearly enough will say something before they quietly decide to leave. That's the bet this build set out to test.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article