You know that rush of excitement where you’ve been deeply engaged coding an intriguing project on your laptop, it’s all going along swimmingly, and it’s running perfectly? Then comes the plummeting realization… no one else can use it?

That’s where I found myself last week with my AI Beauty Analyzer project. I felt it was a moment of victory combined with a little bit of despair, where I considered how I could release it into the world.

The objective of the week was closing the gap — freeing my skin analysis code from the grip of localhost and giving it a proper home out on the cloud, where real people could go and mess with it.

The Thrilling Find That Began Week 2!

Imagine this: I’m excitedly showing off my beauty analyzer app at a catch-up with a friend, and with enthusiasm as she asks, “Can I use it on my phone?”

I paused for a moment and thought about all the technical steps it required. “You’d want to clone my repository from GitHub, get Python installed, create a virtual environment, and then execute a set of dependencies…” I could see her eyes start to glaze over. Evidently, the technical speak wasn’t taking hold with her; she just needed something easy and fun.

This is where the lightbulb moment hit me — an API was just the right solution! I could create an easy-to-use application programming interface so that anyone, regardless of their technical background, could easily use my beauty analyzer. This would help users easily incorporate the analyzer into their apps or simply use the analyzer through their devices. Great times lay ahead as I saw a future where beauty diagnostics would be within anyone’s fingertips!

Imagine this: I’m excitedly showing off my beauty analyzer app at a catch-up with a friend, and with enthusiasm as she asks, “Can I use it on my phone?”

I paused for a moment and thought about all the technical steps it required. “You’d want to clone my repository from GitHub, get Python installed, create a virtual environment, and then execute a set of dependencies…” I could see her eyes start to glaze over. The technical speak wasn’t taking hold with her; she just needed something easy and fun.

This is where the lightbulb moment hit me — an API was just the right solution! I could create an easy-to-use application programming interface so that anyone, regardless of their technical background, could easily use my beauty analyzer. This would help users easily incorporate the analyzer into their apps or use the analyzer through their devices. Great times lay ahead as I saw a future where beauty diagnostics would be within anyone’s fingertips!

What I Built This Week

The Mission: Turn my skin type analyzer into something accessible via a simple HTTP request.

The Stack:

• AWS Lambda (since we don’t have time for server administration)

• API Gateway (the gateway that allows the proper requests through)

• A healthy dose of testing paranoia

The Goal: One ought to be capable of sending a POST request along with their skin type and get a significant response. That’s it.

Building My First “Production-ish” Lambda

I’ll be honest — my Lambda function this week was pretty simple. It just takes an input of skin type (oily, dry, combination, sensitive) and returns an affirmation. No earth-shattering AI magic yet.

But here’s the thing I’ve learned from past projects: start with the plumbing, add the intelligence later.

I structured the code knowing that in a few weeks, this simple function will be orchestrating calls to computer vision models and skincare databases. My future self will appreciate that my present self is thinking ahead.

{ "skinType": "oily", "message": "Received skin type analysis request", "status": "processed" }

It isn’t sexy, but it gets the work done. Performance is what it’s all about in the serverless computing universe.

API Gateway: My New Best Friend

Setting up the API Gateway was like learning a new language at first. CORS policies, request mapping, deployment phases — it’s a lot.

Then I reached that endpoint for the first time and saw my JSON response return clean in Postman, and I literally performed a mini victory dance in the living room of my apartment complex. (Fortunately, my neighbors can’t see through walls.)

The brilliance of the API Gateway is that all of this HTTP mess I don’t want to deal with is taken care of. Rate limiting? Done. Authentication hooks for later? Got it. Monitoring? Built in.

Testing: The Unglamorous Hero of This Story

I tested this thing three ways to Sunday:

• Locally with SAM CLI — Since nothing compares to the instant feedback loop of local testing. No waiting on deployment, no AWS costs while I sort out rudimentary bugs.

• cURL from terminal — Quick and dirty. Great for those “did I break it?” moments between code changes.

• Postman for the entire journey — Clean UI, saved requests, correct response formatting. This is where I saw my API come alive.

Every method highlighted different problems. Local testing highlighted syntax errors. cURL highlighted issues with request formatting. Postman highlighted issues with response structure that I wouldn’t have spotted otherwise.

The CI/CD Pipeline That Saved My Sanity

To simplify my process further, I implemented automatic deployment with a GitHub Actions pipeline. This further meant I didn’t have to deploy manually each time I modified.

I have a procedure that does the following:

• Runs tests whenever code is pushed

• Builds the Lambda package

• Automatically deploys to AWS

• Gives me a Slack notification (since I like that personal touch)

The initial code push and being able to view it deploy itself automatically without the AWS console? Perfection.

This degree of automation enables solo development to be sustainable.

What I Learned (Aside from “Serverless is Very Cool”)

• Begin smaller than you imagine — My first version attempted too much. Reduced it back to the fundamental function and built from there.

• Test early, test often, test differently — Each testing method revealed different insights. Don’t rely on just one.

• Documentation is love — Future me (and anyone who might contribute) will appreciate the README I’m writing along the way.

• AWS logs are your friend — CloudWatch is your debugging friend. Those Lambda logs helped me avoid hours of guessing.

The Plot Twist I Didn’t See Coming

The most interesting part of this week wasn’t the technical implementation; it was realizing how this simple API completely changes how I think about the project.

Before: “I’m building a skin analysis tool.”

After: “I’m building a beauty tech platform.”

That shift in perspective is already influencing my Week 3 plans in ways I didn’t expect.

What’s Coming in Week 3

Things get exciting next week. I am integrating the AI model that will analyze skin characteristics and give tailored product suggestions.

The infrastructure is now solid enough to handle real AI workloads. The API can accept image uploads. The response format is locked in. Time to make this thing exceedingly intelligent.

A Question for You

Hey! I’d love to know about your API testing approaches! Team Postman, Team cURL, or something else? Besides that, if you’re interested in the future of beauty tech involving AI, what issues would you want an AI beauty analyzer to address? I want to brainstorm new things with you! Let’s dig into these cool subjects!