
Personal branding in engineering has a simple test: can a stranger look at your public work and tell what you are good at? A page that says “passionate about cloud” fails the test. A small repository that demonstrates a webhook handler surviving duplicate deliveries, with a clear write-up and a test that proves it, passes. This guide walks through building exactly that project, in order, with the operating habits known as ServerlessOps built in from the first commit. It takes a few evenings and leaves you with something you can link from a profile and discuss for ten minutes in an interview.
The technical reasoning follows the practices described in the Atlas entry on ServerlessOps, which defines the field as operating function-based workloads and notes that its label is historical while the work remains mainstream. That second point suits a branding project well: you are demonstrating a skill that employers still want, whatever name the job advertisement uses.
Step 1: pick a narrow, realistic scenario
Choose a webhook that has a real-world effect when processed twice. A payment-confirmation callback is the classic one, but a ticket-creation hook or an order-shipped notification works equally well. Use a sandbox or a mock; do not touch real money or real customer data, and keep every credential out of the repository.
Write the scenario in three sentences at the top of your README: what arrives, what the handler does, and what would go wrong if the same call arrived twice. This framing is the hook that makes a reviewer keep reading.
Step 2: decide how work reaches your code
Place a queue between the public endpoint and the processing function. The endpoint’s only job is to validate the request and enqueue it, then return quickly. Processing happens asynchronously, so the sender is never kept waiting on your slow parts. Document why you did this; the choice of invocation model is the first thing the Atlas asks you to pin down, and explaining it shows you understand how failure behaviour depends on it.
If you package your function as a container image, the habits from a guide to managing Docker images for engineering teams apply directly: small images, pinned base versions and clear tagging make the project easier to reproduce on another machine.
Step 3: choose the duplicate key
This is the heart of the project, so spend time on it. The key must identify the business event, not the delivery. A webhook usually carries an event identifier or an order reference; use it. Leave the platform’s per-delivery tag out of it: replays are stamped afresh, and a guard built on it would let them through.
Write down, in the README, what you chose and why. A single paragraph of reasoning here is worth more than a hundred lines of code.
Step 4: store the key with a sensible lifetime
Create a small table for processed keys with an expiry attribute. Now decide the lifetime, and treat the decision as a design question. It should exceed the longest outage you want to survive, otherwise a replay after a long pause slips past the guard. The Atlas observes that a popular helper library defaults to one hour, while its own example uses fifteen days. It also notes that a payment provider may prune its own keys after twenty-four hours, so a replay is only protected for the shorter of your expiry and the provider’s retention.
Pick a number, justify it in two sentences, and make it configurable. Showing that you thought about the lifetime separates a considered project from a copied tutorial.
Step 5: write the handler so the check comes first
The order of operations matters. Check the key, perform the effect, then record completion, and handle the narrow gap between the second and third. A common technique is to write an “in progress” marker atomically before acting, so two concurrent copies cannot both proceed. Whichever approach you choose, explain the failure case where the function dies after the effect but before the record, and say what your design does about it.
Where your effect touches another service, pass the same key along if that service supports one. A project that shows protection at two layers, yours and the destination’s, signals the right instinct.
Step 6: attach a failure destination with an owner
Give the queue a dead-letter queue, set its retention longer than the source, add an alarm for any arrival and write a one-paragraph note naming who would look at it. In a personal project the owner is you, but write it down anyway; a note like that shows you think in terms of operations, not just code. The Atlas’s illustration of fourteen days of retention against four on the source is a handy reference value to cite.
Step 7: set limits that nest
Configure three numbers in order. The call from the function to anything downstream should time out first. The function’s own limit comes next. The queue’s visibility window should be several times the function’s limit. The Atlas’s rule of thumb is a factor of six. Add a concurrency cap sized to what your mock destination can accept, and note the reason. Reviewers like to see a number with a justification beside it.
The reading in a short catalogue of beginner Docker slip-ups worth steering clear of has a similar spirit: most mistakes come from unexamined defaults, and the fix is to make each default a decision.
Step 8: build the duplicate-storm test
This is the demonstration that sells the project. Write an automated test that delivers the same event several times, including once out of order and once after a simulated delay, and asserts that the effect happened exactly once. Add a second test where the downstream call fails the first two times, and assert that the final result is still one effect. Print a small table in the test output showing deliveries versus effects.
Consider also reproducing the comparison the Atlas describes: a naive handler, one that records without a business key and one that does both. Seeing three numbers drop to zero is persuasive. Make sure the numbers you publish come from your own runs, not copied figures.
Step 9: add four numbers and one chart
Instrument the project to report the business success rate, duplicates caught, failure-queue depth and oldest age, and cost per thousand events, even if the cost is estimated from the billing formula. One screenshot or generated chart in the README is enough. It proves you know what to measure, and it gives the page a visual anchor.
Step 10: write the article, not just the README
Publish a post of about a thousand words with a plain structure: the problem, the design choices, the tests, what failed along the way and what you would do next. The “what failed” part is the most valuable, because it shows judgement. Link to the repository, include the test output, and cite your references properly. Following sound container practice, as described in a guide to Docker best practices across development and production, will also give you a short section on how to run the project locally.
Step 11: present it
On your profile, describe the project in one sentence that states the outcome: “A webhook handler that produces exactly one effect across retries, replays and slow dependencies, with tests.” Pin the repository, and write two lines on what you learned. In interviews, be ready to explain the key choice, the expiry choice and the nesting of timeouts. Be honest about scope: say that it is a demonstration at small scale and describe what would change in production.
A suggested schedule
Four evenings is realistic. Evening one: steps one to three, ending with the README scenario and the key decision written down. Evening two: steps four to six, ending with a working handler and a failure queue. Evening three: steps seven and eight, ending with passing duplicate tests. Evening four: steps nine to eleven, ending with a published article. Stop each evening at a point where the repository is in a working state, so you can resume without rereading your own code.
Common pitfalls
- Copying a tutorial wholesale. Reviewers recognise the standard examples. Change the scenario and the design choices.
- Claiming exactly-once from the platform. The Atlas lists blind faith in platform guarantees among its anti-patterns; show that your handler supplies the guarantee itself.
- Hiding the limits. State the timeouts, caps and expiries openly.
- Skipping the failure path. A project that only demonstrates success is a tutorial, not evidence of operations skill.
Do the steps in order, keep the scope small and finish the write-up. A finished small project is a better brand than an ambitious unfinished one.








