When we started building Astrolord, we knew we had a tricky engineering problem on our hands. We were building an AI-powered astrology platform that needed to perform heavy astronomical calculations one second and stream personalized AI responses the next. We needed infrastructure that could handle a sudden spike in traffic, like during a major planetary transit, without burning a hole in our pocket during quiet hours.

We decided early on to go all-in on AWS Serverless. It wasn’t just about avoiding server management; it was about building an architecture that could scale to zero when no one was using it, and scale up infinitely when they were. Here is a look at how we pieced it all together.

The Compute Layer: AWS Serverless

The heart of our backend is Python. The challenge was deploying our application in a way that didn’t require maintaining a fleet of servers or paying for idle time.

We chose AWS Lambda for its efficiency. By adapting our web application to run in a serverless environment, we can write modern, clean code while letting AWS handle the underlying infrastructure.

There were trade-offs, of course. We had to be careful with "cold starts", the initial delay when a function wakes up. We spent time optimizing our application startup to keep latency minimal. But the benefit of paying literally zero dollars when no traffic is hitting the API made it an easy choice.

The Front Door: API Gateway

Sitting in front of those Lambda functions is Amazon API Gateway. Connective tissue is often overlooked, but for us, this piece is critical. It acts as our secure entry point, routing requests to the correct backend services.

Beyond just routing, we rely on it for stability. We configured usage plans and throttling rules directly at the gateway level. This means if a bad actor tries to hammer our API, AWS blocks them before they even wake up our compute layer, saving us money and processing power.

Delivering the UI: S3 and CloudFront

For the frontend, we built a static React application. We didn’t want to run a web server or manage containers just to serve HTML and JavaScript files.

Instead, we use what I consider the "gold standard" for static hosting: Amazon S3 paired with CloudFront. We upload our build artifacts into an S3 bucket, which offers incredible durability. Then, CloudFront sits in front of that bucket, caching our application at edge locations all over the world.

The result is that a user in Mumbai loads the app just as fast as a user in New York. We also configured strict security controls, ensuring that no one can bypass the CDN to hit our bucket directly.

Observability

One thing they don’t tell you about distributed systems is that debugging can be a nightmare if you aren’t prepared. Since we don’t have a single server to SSH into, we rely heavily on centralized logging and monitoring.

We capture all standard output from our functions into CloudWatch Logs. We also set up specific metric filters to track errors and throttling events. If our error rate crosses a certain threshold, an alarm triggers and we get notified immediately. It gives us the confidence to deploy on a Friday (well, almost).

The Economics of Serverless

One of the biggest wins for us wasn’t just technical, it was financial.

With a traditional EC2 or container-based architecture, you are paying for capacity 24/7. Even if no one visits your site at 3 AM, that server is still running, and you are still receiving a bill.

With this serverless setup, our infrastructure cost aligns perfectly with our business growth.

• Zero Idle Costs: When our app is quiet, our compute bill is literally $0.
• Generous Free Tier: AWS offers a substantial free tier for Lambda and API Gateway, meaning we effectively run our development and testing environments for free.
• No Over-Provisioning: We never have to guess how many servers we need. The system just scales to meet demand, whether that’s 5 users or 5,000.

Why This Architecture Works for Us

Usage patterns in our app are unpredictable. Some days are quiet; other days, everyone wants to know what the full moon means for them.

This serverless architecture on AWS absorbs that volatility perfectly. We don’t have to provision for peak capacity and pay for idle time. We just pay for the milliseconds of compute we actually use. It has allowed us to focus less on "keeping the lights on" and more on improving the actual product.