Secrets Manager Cross-Account Replication: Setup Guide
Secrets Manager cross-account replication has been available since November 13, 2026, and for me it is one of the most useful AWS releases of the week. If you work with several AWS accounts, you know the problem: an API
Secrets Manager cross-account replication has been available since November 13, 2026, and for me it is one of the most useful AWS releases of the week. If you work with several AWS accounts, you know the problem: an API key or a database password is maintained centrally, but five other accounts need it. Until now that meant a resource policy on the secret, a grant on the KMS key, and every Lambda reaching across account boundaries into the central account. It works, but it feels like running a garden hose through three neighborsβ yards.
With the new feature, each account gets its own copy that stays up to date automatically. In this article I build the whole setup once: two accounts, two KMS keys, one replication role and a Lambda that only reads locally. You get AWS CDK, TypeScript and every command you need.
In short
Secrets Manager can now replicate a secret into another AWS account in the same Region, including rotations. The consuming account then reads only its own copy and no longer needs access to the central account. The biggest pitfall is KMS permissions: without customer managed keys on both sides and a matching key policy, the replica gets stuck in βFailedβ.
What you will learn in this article
- How primary secret, replica and replication role work together
- When a replica beats shared access through a resource policy
- The complete setup with AWS CDK, the AWS CLI and a TypeScript Lambda
- How to check the replication status and fix errors
- How to stop a replica cleanly or turn it into a standalone secret
What is Secrets Manager cross-account replication?
AWS Secrets Manager is the vault for credentials in AWS: passwords, API keys, OAuth tokens. For a while now it has been able to copy a secret into other Regions. What is new is that this also works across account boundaries. There are two roles involved:
- Primary secret in the primary account: the original. This is where the value is maintained and rotated.
- Replica secret in the replica account: an independent resource with its own KMS key, its own resource policy and its own tags. It receives every value change of the primary automatically.
According to the documentation, the value with its versions, the description, the secret type and the staging labels such as AWSCURRENT and AWSPREVIOUS are replicated. Tags, resource policy and KMS key, on the other hand, are managed by each account itself. That is exactly right: who may read in the replica account is decided by the replica account.
You should know a few hard rules up front. Primary and replica must live in the same Region. You get one cross-account replica per primary secret, no more. In addition, the replica has to be encrypted with a customer managed KMS key, because the AWS managed key aws/secretsmanager cannot be used from another account. Replication also runs asynchronously, so the copy is βeventually the sameβ, not identical within the same millisecond.
Shared access or Secrets Manager cross-account replication?
Before we build anything, a closer comparison is worth it. The classic way of sharing a secret across accounts is not wrong. It does have properties that hurt in larger landscapes, though.
Left: the previous shared access, right: the new replica in your own account
| Question | Shared access (before) | Replica (new) |
|---|---|---|
| Where does the Lambda read? | In the central account, across accounts | In its own account |
| Who needs permissions on the central KMS key? | Every reading role from every account | Only the replication role |
| What happens if the central account is compromised? | All readers depend on it directly | The replica can be detached and keeps working on its own |
| Rotation | Visible to everyone immediately | Follows asynchronously |
| Cost | One secret | One additional secret per replica plus KMS keys |
| Infrastructure as code | Fully supported | Replica and association currently via API/CLI |
Shared access and replica compared
My rule of thumb: if only a single account reads along occasionally, shared access stays simpler. If many workloads in several accounts depend on one centrally maintained secret, or you need an emergency copy in an isolated recovery account, the replica is the cleaner architecture. The runtime dependency disappears; what remains is a dependency when the value changes.
How replication works
Every value change on the primary, for example a PutSecretValue or a rotation, triggers replication. To do this, Secrets Manager decrypts the data key with the KMS key of the primary account and re-encrypts it with the key of the replica account. For these two KMS calls the service needs an identity. You can choose:
- Replication role (recommended): an IAM role in the primary account that Secrets Manager assumes. Only this role needs permissions on both keys.
- Forward access session (FAS): Secrets Manager uses the permissions of whoever changed the value. Then every writing identity, including a rotation Lambda, needs encrypt permissions on the foreign key.
In this article I go with the role. With FAS, the cross-account KMS permissions spread across all writing roles, and that is exactly what we wanted to get rid of.
π¬ Cross-account replication flow β this animated diagram only runs on my site: watch it on sascha-ms.de
Prerequisites
- Two AWS accounts in the same AWS Organization, in this example
111111111111(platform, primary) and222222222222(booking, replica). Other organizations work too, see below. - Two CLI profiles, here
platformandbooking, and a current AWS CLI v2 that knows the new commands. - Node.js 22 or newer and an account prepared with
cdk bootstrapon both sides. - For the role that creates the replica:
secretsmanager:CreateSecretandsecretsmanager:PutResourcePolicy, because Secrets Manager attaches a managed resource policy on creation.
The example is a fictional bike rental. The platform team maintains the API key of the payment provider. The booking service runs in its own account and needs this key for every payment.
Set up Secrets Manager cross-account replication step by step
One special point first: at the time of writing, CloudFormation does not offer a property for the replica yet, and it is also missing in aws-cdk-lib 2.277. That is why I build keys, role and Lambda with CDK, while the CLI creates and associates the replica. Because the key policy and the secret ARN depend on each other, each stack is deployed twice. Sounds tedious, but it is done in ten minutes.
Step 1: The CDK project
The app knows two stacks, one per account. The ARNs that only become known later are passed in as context parameters.
// bin/app.ts
import { App } from 'aws-cdk-lib';
import { PrimaryAccountStack } from '../lib/primary-account-stack.js';
import { ReplicaAccountStack } from '../lib/replica-account-stack.js';
const app = new App();
// Account IDs and region come from cdk.json or via -c on the command line
const region = app.node.tryGetContext('region') ?? 'eu-central-1';
const primaryAccount = app.node.tryGetContext('primaryAccount') ?? '111111111111';
const replicaAccount = app.node.tryGetContext('replicaAccount') ?? '222222222222';
// Only known after the replica secret has been created (step 4)
const replicaSecretArn: string | undefined = app.node.tryGetContext('replicaSecretArn');
const replicaKeyArn: string | undefined = app.node.tryGetContext('replicaKeyArn');
new PrimaryAccountStack(app, 'BikeRentalSecretsPrimary', {
env: { account: primaryAccount, region },
replicaSecretArn,
replicaKeyArn,
});
new ReplicaAccountStack(app, 'BikeRentalBookingReplica', {
env: { account: replicaAccount, region },
primaryAccountId: primaryAccount,
replicaSecretArn,
});
Step 2: Primary account with key and primary secret
In the primary account you create a customer managed KMS key and the primary secret. The replication role is only added once the ARNs from the replica account are known. Its trust policy allows only Secrets Manager, and only for exactly this secret. This prevents the so-called confused deputy problem, where a service misuses the role on behalf of someone else.
// lib/primary-account-stack.ts
import { CfnOutput, RemovalPolicy, Stack, type StackProps } from 'aws-cdk-lib';
import * as iam from 'aws-cdk-lib/aws-iam';
import * as kms from 'aws-cdk-lib/aws-kms';
import * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager';
import type { Construct } from 'constructs';
export interface PrimaryAccountStackProps extends StackProps {
/** ARN of the replica secret in the other account (from step 5) */
readonly replicaSecretArn?: string;
/** ARN of the KMS key in the replica account (from step 5) */
readonly replicaKeyArn?: string;
}
export class PrimaryAccountStack extends Stack {
constructor(scope: Construct, id: string, props: PrimaryAccountStackProps) {
super(scope, id, props);
// Customer managed key: required when a replication role has to decrypt
const primaryKey = new kms.Key(this, 'PrimaryKey', {
alias: 'alias/bikerental-secrets-primary',
description: 'Encrypts the centrally managed secrets of the bike rental',
enableKeyRotation: true,
removalPolicy: RemovalPolicy.RETAIN,
});
// The primary secret. Set the real API key afterwards with put-secret-value.
const paymentSecret = new secretsmanager.Secret(this, 'PaymentProviderApiKey', {
secretName: 'bikerental/payment-provider-api-key',
description: 'API key of the payment provider, maintained by the platform team',
encryptionKey: primaryKey,
generateSecretString: { passwordLength: 40, excludePunctuation: true },
removalPolicy: RemovalPolicy.RETAIN,
});
new CfnOutput(this, 'PrimarySecretArn', { value: paymentSecret.secretArn });
// The role is only created once the replica secret and replica key are known
if (!props.replicaSecretArn || !props.replicaKeyArn) {
return;
}
const replicationRole = new iam.Role(this, 'ReplicationRole', {
roleName: 'bikerental-secret-replication',
description: 'Assumed by Secrets Manager for cross-account replication',
// Protection against the confused deputy problem: only for exactly this secret
assumedBy: new iam.ServicePrincipal('secretsmanager.amazonaws.com').withConditions({
StringEquals: { 'aws:SourceAccount': this.account },
ArnEquals: { 'aws:SourceArn': paymentSecret.secretArn },
}),
});
// 1. Decrypt the data key of the primary secret
replicationRole.addToPolicy(
new iam.PolicyStatement({
sid: 'DecryptPrimary',
actions: ['kms:Decrypt'],
resources: [primaryKey.keyArn],
conditions: {
StringEquals: { 'kms:EncryptionContext:SecretARN': paymentSecret.secretArn },
},
}),
);
// 2. Re-encrypt for the replica in the other account
replicationRole.addToPolicy(
new iam.PolicyStatement({
sid: 'EncryptReplica',
actions: ['kms:Encrypt'],
resources: [props.replicaKeyArn],
conditions: {
StringEquals: { 'kms:EncryptionContext:SecretARN': props.replicaSecretArn },
},
}),
);
new CfnOutput(this, 'ReplicationRoleArn', { value: replicationRole.roleArn });
}
}
A note on the key policy: by default, CDK creates a policy that delegates permissions to IAM in its own account. That is why the identity policy of the role is enough here. If you use a stricter key policy without this delegation, you also have to add the role there for kms:Decrypt.
# In the primary account (profile "platform")
npm install
npx cdk deploy BikeRentalSecretsPrimary --profile platform \
-c primaryAccount=111111111111 -c replicaAccount=222222222222
From the output, keep PrimarySecretArn as PRIMARY_SECRET_ARN.
Step 3: Create the key in the replica account
At first, the replica stack only creates the KMS key. As soon as the replica exists, the second deployment adds the grant for the primary account and the Lambda.
// lib/replica-account-stack.ts
import { CfnOutput, Duration, RemovalPolicy, Stack, type StackProps } from 'aws-cdk-lib';
import * as iam from 'aws-cdk-lib/aws-iam';
import * as kms from 'aws-cdk-lib/aws-kms';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
import type { Construct } from 'constructs';
export interface ReplicaAccountStackProps extends StackProps {
/** Account that owns the primary secret */
readonly primaryAccountId: string;
/** ARN of the replica secret (from step 5) */
readonly replicaSecretArn?: string;
}
export class ReplicaAccountStack extends Stack {
constructor(scope: Construct, id: string, props: ReplicaAccountStackProps) {
super(scope, id, props);
// The key belongs to the replica account, not to the platform team
const replicaKey = new kms.Key(this, 'ReplicaKey', {
alias: 'alias/bikerental-booking-replica',
description: 'Encrypts the replica of the payment provider key',
enableKeyRotation: true,
removalPolicy: RemovalPolicy.RETAIN,
});
new CfnOutput(this, 'ReplicaKeyArn', { value: replicaKey.keyArn });
if (!props.replicaSecretArn) {
return;
}
// The primary account may use this key only to encrypt exactly this replica
replicaKey.addToResourcePolicy(
new iam.PolicyStatement({
sid: 'AllowCrossAccountReplication',
principals: [new iam.AccountPrincipal(props.primaryAccountId)],
actions: ['kms:Encrypt'],
resources: ['*'],
conditions: {
StringEquals: { 'kms:EncryptionContext:SecretARN': props.replicaSecretArn },
},
}),
);
// The booking Lambda only reads locally in its own account
const bookingFn = new NodejsFunction(this, 'BookingFunction', {
entry: 'src/booking-handler.ts',
runtime: lambda.Runtime.NODEJS_24_X,
architecture: lambda.Architecture.ARM_64,
memorySize: 256,
timeout: Duration.seconds(10),
environment: {
PAYMENT_SECRET_ARN: props.replicaSecretArn,
SECRET_CACHE_SECONDS: '300',
},
});
bookingFn.addToRolePolicy(
new iam.PolicyStatement({
actions: ['secretsmanager:GetSecretValue'],
resources: [props.replicaSecretArn],
}),
);
replicaKey.grantDecrypt(bookingFn);
new CfnOutput(this, 'BookingFunctionName', { value: bookingFn.functionName });
}
}
# In the replica account (profile "booking")
npx cdk deploy BikeRentalBookingReplica --profile booking \
-c primaryAccount=111111111111 -c replicaAccount=222222222222
The output ReplicaKeyArn becomes REPLICA_KEY_ARN.
Step 4: Create the replica secret
Now the replica account creates an empty secret that points to the primary. Secrets Manager automatically attaches a managed resource policy named cross-account-replication, which allows the primary account to set up replication.
# In the replica account: create an empty replica that points to the primary secret
aws secretsmanager create-secret --profile booking \
--name bikerental/payment-provider-replica \
--cross-account-primary-arn "$PRIMARY_SECRET_ARN" \
--kms-key-id "$REPLICA_KEY_ARN"
The ARN in the response is your REPLICA_SECRET_ARN. Until the first synchronization, GetSecretValue on the replica returns ResourceNotFoundException, by the way. That is not an error, just an empty vault.
Step 5: Complete the permissions
With both ARNs in hand, you deploy both stacks a second time. In the replica account, the key policy then allows the primary account to call kms:Encrypt, but only with the encryption context of this one replica. In the primary account, the replication role is created.
# Replica account: add the key policy statement and the Lambda
npx cdk deploy BikeRentalBookingReplica --profile booking \
-c primaryAccount=111111111111 -c replicaAccount=222222222222 \
-c replicaSecretArn="$REPLICA_SECRET_ARN"
# Primary account: add the replication role
npx cdk deploy BikeRentalSecretsPrimary --profile platform \
-c primaryAccount=111111111111 -c replicaAccount=222222222222 \
-c replicaSecretArn="$REPLICA_SECRET_ARN" -c replicaKeyArn="$REPLICA_KEY_ARN"
You need the output ReplicationRoleArn as REPLICATION_ROLE_ARN and, later on, BookingFunctionName as BOOKING_FUNCTION_NAME.
Step 6: Associate the replica and check the status
The primary account takes the last step. associate-cross-account-replica first runs a dry-run check of the KMS permissions on both sides, links the secrets and starts the first copy. By default, SameOrg applies: the replica account has to be in the same organization. For an external account, you deliberately set --replica-restriction NoRestriction.
# In the primary account: associate the replica and start replication
aws secretsmanager associate-cross-account-replica --profile platform \
--secret-id "$PRIMARY_SECRET_ARN" \
--cross-account-replica-arn "$REPLICA_SECRET_ARN" \
--replication-role-arn "$REPLICATION_ROLE_ARN"
# Wait until the status reports InSync
AWS_PROFILE=platform npx tsx scripts/wait-for-replication.ts "$PRIMARY_SECRET_ARN"
This small script calls DescribeSecret every five seconds and stops with the error message on Failed. You can run it in a pipeline after the deployment just as well.
// scripts/wait-for-replication.ts
import { DescribeSecretCommand, SecretsManagerClient } from '@aws-sdk/client-secrets-manager';
const secretId = process.argv[2];
const maxAttempts = Number(process.argv[3] ?? '24');
const client = new SecretsManagerClient({});
if (!secretId) {
console.error('Usage: npx tsx scripts/wait-for-replication.ts <primary-secret-arn> [attempts]');
process.exit(2);
}
const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
for (let attempt = 1; attempt <= maxAttempts; attempt++) {
const secret = await client.send(new DescribeSecretCommand({ SecretId: secretId }));
const replica = secret.CrossAccountReplicas?.[0];
if (!replica) {
console.error('No cross-account replica associated.');
process.exit(1);
}
console.log(`Attempt ${attempt}: ${replica.ReplicationStatus} -> ${replica.ReplicaSecretARN}`);
if (replica.ReplicationStatus === 'InSync') {
process.exit(0);
}
if (replica.ReplicationStatus === 'Failed' || replica.ReplicationStatus === 'Detached') {
console.error(`Aborting: ${replica.StatusMessage ?? 'no details'}`);
process.exit(1);
}
await sleep(5000);
}
console.error('Time limit reached, replica is not InSync yet.');
process.exit(1);
Expected result:
Attempt 1: InProgress -> arn:aws:secretsmanager:eu-central-1:222222222222:secret:bikerental/payment-provider-replica-AbCdEf
Attempt 2: InSync -> arn:aws:secretsmanager:eu-central-1:222222222222:secret:bikerental/payment-provider-replica-AbCdEf
Step 7: The Lambda only reads locally
Now the booking Lambda only needs two permissions in its own account: GetSecretValue on the replica and kms:Decrypt on its own key. It keeps the value in memory for five minutes, so not every invocation has to ask Secrets Manager.
// src/booking-handler.ts
import {
GetSecretValueCommand,
ResourceNotFoundException,
SecretsManagerClient,
} from '@aws-sdk/client-secrets-manager';
const client = new SecretsManagerClient({});
const secretArn = process.env.PAYMENT_SECRET_ARN ?? '';
const cacheMs = Number(process.env.SECRET_CACHE_SECONDS ?? '300') * 1000;
let cached: { value: string; versionId: string; loadedAt: number } | undefined;
// Reads the replica from its own account and keeps it in memory for a short time
export async function getPaymentApiKey(now = Date.now()) {
if (cached && now - cached.loadedAt < cacheMs) {
return cached;
}
try {
const result = await client.send(new GetSecretValueCommand({ SecretId: secretArn }));
cached = {
value: result.SecretString ?? '',
versionId: result.VersionId ?? 'unknown',
loadedAt: now,
};
return cached;
} catch (error) {
if (error instanceof ResourceNotFoundException) {
// Typical right after creation: the replica has no value yet
throw new Error('Replica not synchronized yet - check the status in the primary account');
}
throw error;
}
}
export const handler = async () => {
const apiKey = await getPaymentApiKey();
// Never log the value, only metadata
console.log(JSON.stringify({ message: 'API key loaded', versionId: apiKey.versionId }));
return {
statusCode: 200,
body: JSON.stringify({ keyLoaded: apiKey.value.length > 0, versionId: apiKey.versionId }),
};
};
To test it, set the real value in the primary account and invoke the Lambda afterwards. After a few seconds it should report the new version ID. Rotations behave the same way: the staging labels move along, and the Lambda reads AWSCURRENT as usual.
# Primary account: set the real API key (the value comes from a file, not from your shell history)
aws secretsmanager put-secret-value --profile platform \
--secret-id "$PRIMARY_SECRET_ARN" \
--secret-string file://payment-provider-key.txt
# Replica account: invoke the Lambda and compare the version ID
aws lambda invoke --profile booking \
--function-name "$BOOKING_FUNCTION_NAME" response.json && cat response.json
I described how to build the rotation itself in Secrets Manager rotation with Lambda for API keys. Rotation always happens on the primary, because the replica does not accept write operations.
Common errors and how to fix them
Almost every problem I noticed while working through the documentation is about permissions. The good news: the StatusMessage field in DescribeSecret tells you quite precisely what is missing.
Status βFailedβ because of KMS
If it says not authorized to perform: kms:Decrypt, the role lacks the permission on the primary key. With kms:Encrypt, either the grant in the key policy of the replica account is missing, or the encryption context does not match the replica ARN. Watch out: a secret ARN ends with a random suffix such as -AbCdEf, and exactly this full ARN has to be in the condition. After the fix, simply call associate-cross-account-replica again. The call is idempotent and only triggers a new attempt.
The role cannot be assumed
The message failed to assume role almost always points to the trust policy: a wrong service principal or an aws:SourceArn that does not match the primary secret exactly. Even when everything is correct, a service control policy (SCP) or resource control policy (RCP) of your organization can block the KMS calls. The documentation states this explicitly, and it is the error you will search for the longest.
More pitfalls
-
AWS managed key:
aws/secretsmanagerworks neither for the replica nor for the primary when a replication role is involved. - Second replica: only one cross-account replica is allowed per primary. If five accounts need the value, that means five primaries or a different distribution model.
-
Writing to the replica:
PutSecretValue,UpdateSecret,RotateSecretand evenDeleteSecretreturnInvalidRequestException. -
Deleting the primary: as long as a replica is associated,
DeleteSecreton the primary fails. -
External organization: without
NoRestriction, the association ends withAccessDeniedException. The setting only counts for the first association.
Stop a replica or turn it into a standalone secret
For emergencies, this may be the most important part. If the primary account is compromised or a team should become independent, the replica account can cut the connection itself. stop-replication-to-replica turns the replica into a normal, writable secret. Conversely, the primary account can stop delivering with disassociate-cross-account-replica. The replica then stays in the Detached status until the replica account releases it as well.
# Option 1, in the replica account: the replica becomes standalone and the link is cut
aws secretsmanager stop-replication-to-replica --profile booking \
--secret-id "$REPLICA_SECRET_ARN"
# Option 2, in the primary account: remove the association (the replica is Detached afterwards)
aws secretsmanager disassociate-cross-account-replica --profile platform \
--secret-id "$PRIMARY_SECRET_ARN" \
--cross-account-replica-arn "$REPLICA_SECRET_ARN"
For stop-replication-to-replica the role also needs secretsmanager:DeleteResourcePolicy, because the managed policy is removed in the process. Especially for emergency plans, it pays off to write this command into a runbook before you need it.
Cost and security
The replica is an independent secret, so count it as an additional secret. According to the pricing page, you pay per secret per month and per 10,000 API calls; the examples there use 0.40 US dollars and 0.05 US dollars respectively. On top of that come the customer managed KMS keys on both sides. For an API key that triggers payments, that is a very manageable price.
On the security side, I like two things. First, the primary key stays in the primary account, and no foreign account gets read access to it. Second, every grant can be restricted to exactly one secret through the encryption context. You should do that, too: a kms:Encrypt without a condition for an entire foreign account is too generous. If you want to check your stacks for such gaps automatically, cdk-nag v3 with Vitest is a good starting point.
My take
I think the replica is the right step, because it implements a principle I generally like in serverless architectures: at runtime, every workload has everything in its own account. Fewer cross-account paths mean fewer sources of error, clearer ownership and less damage when something does go wrong.
Two things dampen my enthusiasm. The limit of one replica per primary does not fit the case I see most often: one secret, many consumers. And as long as CloudFormation does not know the replica, part of the setup lives in CLI commands that tend to disappear into a wiki page. Today I would therefore put it into a script or a pipeline and switch over as soon as CDK supports it natively. For disaster recovery with an isolated vault account, however, I would use the feature right away.
FAQ
Can I replicate a secret into several AWS accounts?
Not from one primary. Each primary secret allows exactly one cross-account replica. For several accounts you need several primaries, or you keep shared access through a resource policy.
Does replication also work into another Region?
No, primary and cross-account replica must be in the same Region. For other Regions there is the familiar multi-Region replication within one account.
Can I create the replica with CloudFormation or CDK?
Not directly at the time of writing. Keys, roles and Lambdas work with CDK; replica and association work with the CLI or an SDK, for example from a pipeline.
What happens to the replica if the primary account fails?
It stays readable with the last value. With stop-replication-to-replica you turn it into a standalone secret that you can then change and rotate yourself.
Your next step
Pick a secret that at least one other account reads through a resource policy today, and walk through the setup in two sandbox accounts. If you still feel like it afterwards, add the status script as a step in your pipeline. I am curious: how do you distribute secrets across your accounts today, and would the limit of one replica per primary bother you?
All code from this article, ready to run: smirowstanitzok/sascha-ms-examples
Secrets are not the only thing that needs clear permissions: I described how to guard critical DNS records against accidental changes with Route 53 record set protection in a separate article.
Sources
- AWS Whatβs New: AWS Secrets Manager now supports cross-account replication (Nov 13, 2026)
- AWS docs: Replicate AWS Secrets Manager secrets across accounts
- AWS docs: Create a replica secret
- AWS docs: Associate the replica with a primary secret
- AWS docs: How Secrets Manager authorizes cross-account replication
- AWS docs: Monitor cross-account replication
- API reference: AssociateCrossAccountReplica
- AWS Secrets Manager Pricing
This post was created with AI assistance.
π Next step: Working with AWS CDK? Grab my printable AWS CDK cheat sheet with commands, concepts and a stack skeleton.
π¬ Stay updated: New articles on serverless, AI and leading tech teams via RSS, browser push or the weekly newsletter (in German).
Originally published on sascha-ms.de. More articles on serverless, AI in everyday development and leading tech teams: sascha-ms.de/en
Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes β full credit and traffic to the original publisher.