ServerlessOps FAQ for Chennai Developers: Straight Answers

ServerlessOps FAQ for Chennai Developers: Straight Answers
Tech How-To

Developers in Chennai, from the IT corridor along OMR to the small agencies in T. Nagar, ask a familiar set of questions once their first cloud-function project meets real users. This page answers them in order, without ceremony. Every fact comes from the Ops Atlas, and each is quoted with its limits so you can compare it with your own account. If a question is not here, the closing section shows where to look.

What does ServerlessOps actually cover?

It covers the day-to-day running of code that a cloud provider executes on demand: how events trigger it, what happens when it fails, how many copies may run at once, how long each run may last, how changes are released, what signals to watch and what it costs per event. The Atlas entry for ServerlessOps also lists what falls outside: the broad debate about whether operations disappear, company-wide cloud governance, workflow engines, message-broker design, telemetry pipelines, overall spend governance and account-level quotas. Those have their own pages.

Is it an official certification or standard?

No. The entry states plainly that nothing formal defines it. The word was a niche practitioner label from roughly 2016 to 2020. The work itself is mainstream, so you will meet it under other names, including plain “cloud engineering.” Do not pay for a course that promises an official ServerlessOps credential.

How long can a single function run?

It depends on the platform, and the numbers have moved over time. In the Atlas list, the main AWS service allows 900 seconds, with a longer 5,400-second limit on its managed-instances option. Google’s container-based service allows a request timeout of up to sixty minutes, and the flex plan on Azure defaults to thirty minutes. Read these as upper bounds rather than goals. Most functions that approach their limit are doing too much in one go and should be split or moved onto a queue.

What happens if a background event fails?

For asynchronous invocations on the main platform, the entry says events may wait in an internal queue for up to six hours, and the platform retries up to two more times. After that, the event is gone unless you pointed it at a dead-letter queue, or at a failure-destination setting. Configure one. A function that fails quietly and leaves no trace is the most expensive kind.

Why did my customer get charged twice?

Almost certainly because the same event was processed twice and your code was not built to notice. Delivery on these platforms is at-least-once. The fix is a record keyed on a business identifier you control, such as the order number, checked before the side effect and passed on to the payment provider too. In the Atlas simulation, adding a record alone cut double charges from 504 to 295 out of 10,000 orders, and adding the business key brought them to zero. Do not use the message ID as your key, because a redrive creates a new one.

Does a FIFO queue prevent duplicates?

Only partly. The entry notes that the duplicate-detection window on that queue type is five minutes and covers the sending side. A consumer that crashes and is retried can still repeat work. Plan for duplicates regardless of queue type.

How should I set the timeouts between a queue and a function?

Nest them. The call your function makes should time out sooner than the function itself. And the queue’s visibility timeout, meaning how long a fetched message stays invisible to other consumers, should span six or more function timeouts, according to the entry. If the hiding period is shorter than the function’s run time, the queue offers the message to someone else while the first run is still working, and you get a duplicate by design.

Are cold starts a real problem?

Rarely. Per the entry, under one call in a hundred begins cold on the flagship service. If you are on a latency-critical path, consider reserved warm capacity or snapshot-based start-up. Scheduled pings are not recommended. Also note that initialisation time is billed as part of duration, so heavy start-up code costs real money.

How much concurrency do I get?

The default pool in the example region is 1,000 simultaneous runs across the account. The page recommends keeping peak use at or below about seventy percent, and warning yourself when headroom falls under thirty percent. If you reserve capacity for a function, you need an unreserved pool of at least the reserved maximum plus one hundred, or the reservation fails.

What does it cost to run?

At the October 2026 rates quoted in the entry, for x86 in the US East region, requests cost $0.20 per million, and compute is $0.0000166667 per gigabyte-second. A worked path in the Atlas totals $3.75 per million events, which works out near $112.58 monthly at the sample volume. Your rates and region will differ, so recompute with your own figures. Billing includes initialisation time, which surprises many first-time users.

Is serverless always cheaper than containers?

No. It is usually economical for uneven or modest load. For steady, heavy traffic, containers or the managed-instances option can be cheaper, even after the fifteen percent management fee on top of the instance price. Measure before you migrate in either direction.

How do I stop retries from piling up?

Choose one layer to retry and have the others fail fast. The sheet quotes the arithmetic that five layers retrying three times each can create 243 times the load. On stream sources, set finite retries, a maximum record age and batch bisection, because the defaults can retry forever.

Which signals should I watch?

Begin with outcomes the customer would recognise: completed requests, repeated side effects, what flows into the failure box and how old its oldest entry is. Then add backlog age, throttling, spare concurrency, the cold-start share and unit cost. Do not rely on the error count alone, since partial batch failures are not reported as errors.

How do I release a change without breaking production?

Use versions and aliases. Send production events to a named alias, let a thin slice of traffic try the new version before the rest, and keep the previous version one step away for a quick rollback. The Atlas points to AWS SAM for canary-style deployments. It also warns about a template quirk: editing nothing but parameters can land only on the unpublished latest build, unless a specific language-extensions transform is enabled. Test by changing a harmless value and reading it back from the live alias.

What do I do about a stream record that keeps failing?

Left alone, one bad record can stall an entire shard, because the default retry setting on stream mappings is unlimited. Cap the attempts, put a ceiling on record age, and turn on batch bisection so the failing item is isolated while the rest proceed. Be aware that the failure destination for streams records only a pointer. Keep the original data somewhere durable if you need to replay it later, since one common change stream keeps entries for just a day.

Who should own the failure queue?

Someone who understands what an unprocessed message means to a customer, which is often a support or operations person rather than the original developer. Name them in the README, route the alarm to the channel they already read, and make the retention longer than the source so a long weekend does not erase the evidence. One example in the entry pairs a two-week failure box with a source that forgets after four days.

Where should a Chennai beginner start?

Pick one function that touches money or customer records and give it a business-key record, a failure destination, a cap and an alarm. Then read a broader career guide such as a simple journey through skills, tools and growth in delivery work, and find a time to relax too: pointers for arranging a first trip to the city are handy when a colleague from another office flies in for the launch.

What if my question is not covered?

For numbers that keep changing, return to the provider’s own documentation, and treat any figure in a blog post, including these, as a snapshot. The habits are stable: assume repeats, own the failure path, set limits, measure outcomes. If you can explain those four in a sentence each to a non-technical colleague, you are already ahead of most teams.