DEV Community: Kiah Imani 🇧🇧

This Week in Cloud: Community Edition

Kiah Imani 🇧🇧 — Fri, 09 May 2025 18:33:42 +0000

AKA: The one where I didn’t break anything on purpose.

This week was less about tinkering with new AWS services and more about turning the spotlight on the community side of cloud development.

If you’ve been following along, you know I’ve spent the last few weeks deep in LocalStack. Testing services, simulating chaos, debugging stateful nightmares (good times!). But this week, I shifted gears. Instead of code, I focused on content and connection.

Building Beyond Support

The LocalStack community is incredibly helpful. People show up daily with questions, bug reports, and clever workarounds. It’s a support-driven space that works. But I’ve been noodling on a bigger goal:

How do we turn a support community into a space for shared learning, storytelling, and collaboration?

I don’t have the full answer yet, but I’ve started experimenting.

🎯 Question of the Week

Two weeks ago, I kicked off a new initiative in our Community Slack: Question of the Week.
The idea is simple, one quick question every Wednesday to spark discussion. Not tech support. Not troubleshooting. Just a prompt to get people talking about how they use cloud tools, what’s working (or not), and how they’re building.

Here are a few early results:

One member broke down their internal LocalStack setup across microservices (it’s innovative and smart).
Another shared how their team uses state restoration to test event-driven systems.
We even got into a small thread about the pros and cons of using Docker Compose vs CLI for repeatable dev setups.

It’s been a good reminder that once you get folks talking, the depth is there, sometimes they just need an invitation.

🎥 Cloud Video Series (Work in Progress)

Behind the scenes, I’ve been working on a short video series aimed at beginners. Think of it as:

“Intro to Cloud (For the Confused and Curious)”

It’s fast-paced, designed to cut through the jargon, and it’s my way of helping more folks understand cloud development without a 20-minute AWS tutorial.

If you're a content creator or video editor, I need your help!
Drop your best editing tips, tools, or pacing tricks below. Especially if you’ve cracked the code on making educational content feel fun and not like a lecture.

🙋🏾‍♀️ Your Turn

If you’ve built or led a developer community, I’d love to learn from you.

What’s worked for you when it comes to activating a quiet community?
Tips, lessons learned, experiments gone wrong — I’m here for all of it.

Let’s build something better than just support threads. Let’s build a space where folks grow.

📬 Want to stay connected?

I’m always sharing behind-the-scenes updates, cloud chaos experiments, and content WIPs. You can find me on Twitter or LinkedIn. Let’s connect!

This Week in Cloud: Unexpected AWS Tour

Kiah Imani 🇧🇧 — Sat, 03 May 2025 02:27:32 +0000

Not every week is about shipping cool projects, sometimes it’s just about testing.
And this week? It was all about testing.

I spent the week running through various LocalStack Pro sample apps to make sure everything worked as expected. What I didn’t expect was to get hands-on with a whole bunch of AWS services I’ve barely touched before (and a few I had honestly never even heard of).

Here’s what I ended up exploring:

SageMaker → Machine learning workflows
RDS → Managed relational databases
Neptune → Graph databases
Step Functions → Orchestration workflows
Glue → Data catalog and ETL
MQ → Managed message brokers
Route 53 → DNS and traffic routing

...plus the usual mix of storage, compute, and API Gateway goodness.

What stood out this week was how much you can learn just by doing. I didn’t plan to dive into graph databases or message brokers, but while debugging and tinkering, I picked up quite a bit.

Having everything local with LocalStack definitely made that exploration easier and less intimidating.

What’s next?

First things first: I need to finish my Meme App (priorities are priorities).

Once that’s wrapped, I’d like to turn some of this accidental learning into small demos and share tips on how to explore unfamiliar AWS services without the usual stress.

If you’ve ever gone down the AWS rabbit hole and come out the other side with new scars and skills, I’d love to hear your story too. Just hit me up on Twitter or LinkedIn. Catch y'all next week!

This Week in Cloud: Simulating Chaos

Kiah Imani 🇧🇧 — Sat, 26 Apr 2025 02:56:35 +0000

Resilient apps aren’t just built, they’re battle tested. This week, I got my second real taste of chaos engineering using LocalStack’s Chaos Dashboard (the first was for my interview project), and let me tell you: it was both humbling and weirdly fun.

I’m still deep into building my serverless meme caption game (yes, still), but I wanted to see how it holds up under failure. Spoiler: not great! But that’s the point.

Wait… what is chaos engineering again?

At a high level, chaos engineering is the practice of intentionally introducing failures into your system to observe how it behaves.

The goal isn’t to break things just for fun (though, it is kinda fun). It’s to build confidence that your app can recover gracefully when issues happen irl. Network glitches, service outages, bad configs, etc.

With LocalStack (the pro version, sorry), I could do this locally using the Chaos Dashboard, which makes it ridiculously easy to simulate things like:

DynamoDB returning 500 errors
S3 being unavailable
Lambda timing out
And a bunch more

My Setup: Meme App Meets Mayhem

I’ve got a simple serverless app:

Users upload memes to S3
They vote on captions stored in DynamoDB
Everything’s wired up via Lambda + API Gateway
I'm using Terraform to manage infra, and running it all in LocalStack

Once I had the basic flow working, I launched the Chaos Dashboard, clicked the “DynamoDB Error” experiment… and watched my app fall apart. Literally.

The Lambda function that calls PutItemAsync in DynamoDB started throwing internal server errors like confetti.

What Went Wrong (And Why That’s Good)

This wasn’t a polished app. It had:

No retries
No fallback logic
No graceful error handling

And I got to see all of that immediately once the chaos kicked in.

Takeaway:

If your app can’t tolerate even a brief hiccup from a cloud service, it’s not ready for prod. And without chaos testing, you might not know until it’s too late.

My Favorite Part: Testing in LocalStack > Prod Nightmares

What I loved about this:

I didn’t need to spin up a real AWS environment
I didn’t risk breaking anything critical
I could toggle failure modes with a literal switch

I will be adding retries and proper logging soon. But even just running this gave me a new perspective on what “robust” actually means.

Turning This into a Talk

This experiment started as a blog post, but it’s shaping up to be something bigger. I’m putting together a lightning talk based on this journey—equal parts meme app, chaos engineering, and “what not to do.”

My goal?

Take this talk on the road to show other devs that you don’t need to be Netflix to start building resilient systems. You just need a curious mind, a busted app, and some good local chaos.

Coming Soon: More Chaos. More Learning.

Next up, I want to test how my app handles:

S3 outages (can users still vote on memes?)
Lambda timeouts (will the frontend hang or recover?)
Multi-service chaos (because AWS failures don’t happen in isolation)

Still building. Still breaking. Still blogging.

If you’ve dabbled in chaos engineering, or you’re curious about trying it, I’d love to hear about it!
Hit me up on Twitter or LinkedIn and let’s swap stories.

Until next week 👋🏾

This Week in Cloud: My First Real Serverless App (and It’s a Meme Game)

Kiah Imani 🇧🇧 — Fri, 18 Apr 2025 17:27:40 +0000

I’ve been adjacent to cloud infrastructure for years, spinning up environments for C-Trax in AWS, learning config management at Chef. But this week at LocalStack felt like the first time I got to really build in the cloud.

Not hypothetically. Not on paper. Actually deploying services, wiring them together, and watching something come to life.

The best part? It all runs locally, so I can break things safely and often.

🧪 The Project: Meme Game, but Make It Serverless

I’m in the middle of building a meme caption game powered by:

API Gateway to expose endpoints
Lambda for scoring and logic
DynamoDB to store game data
S3 for static assets
Terraform to define it all as code

It’s part demo, part sandbox, and 100% the kind of thing I wanted to do with C-Trax, but couldn’t justify the risk back then. Serverless infra felt too new, too unpredictable. But with LocalStack, I can finally dive in without fear of blowing up a production app or the cloud bill.

🛠 Terraform: The Tool I Always Wanted to Learn

I first heard about Terraform while working at Chef. It sounded powerful, declarative, and honestly kind of beautiful, but I never had a good excuse to get hands-on.

That excuse finally arrived.

I’m using Terraform to define and deploy all the pieces of the meme game. And while the syntax threw me at first (and I definitely cursed at a few provider blocks), the “infra as code” lightbulb finally clicked.

⚠️ What Tripped Me Up (In a Good Way)

Terraform + LocalStack Integration

Figuring out the right provider config to talk to LocalStack took some trial and error. But once it worked, it was chef’s kiss.
Lambda Gotchas

Even locally, Lambdas come with quirks like cold starts and subtle packaging issues. Watching logs in real time helped me debug faster than I ever could in AWS.
Endpoint Confusion

I kept forgetting I wasn’t on “real” AWS. LocalStack has its own endpoints and quirks. But once I got the hang of it, I stopped worrying about credentials or billing.

💡 Why This Week Mattered

This wasn’t just “set up a demo app.” It was confidence building. I’ve been around cloud talk for years, but now I’m in it. Writing infra code, testing services, and learning to break and fix things as I go.

With LocalStack, the cloud feels less like a fortress and more like a workshop. I get to play, test ideas, and actually see what’s happening under the hood.

🔮 Up Next

I’m still wrapping up the meme game and will share the repo once it’s ready. Next week, I plan to experiment with chaos engineering. Like simulating a broken DynamoDB and seeing how the app holds up.

If you’ve built something like this, or have tips for a serverless noob, I’d love to hear from you! You can find me on the interwebs on LinkedIn and Twitter (never calling it X).

Thanks for following along! Stay tuned for next week’s adventure in the cloud ☁️

New Job, Who Dis?

Kiah Imani 🇧🇧 — Mon, 14 Apr 2025 15:54:39 +0000

After a long and honestly exhausting job search, I finally get to share some good news: I’ve joined LocalStack as a Senior Developer Relations Engineer.

I’ll be real with y’all, the “Senior” part is mostly for the resume. LocalStack isn’t about titles and ego, and that’s one of the many reasons I said yes.

This wasn’t a quick decision. I had a few offers on the table, but I was holding out for the right one. A place where I could actually grow, not just grind. Funny enough, I interviewed with LocalStack for a different role at first. I didn’t get it. But a few weeks later, they reached back out about a new role they felt was a better fit. (Spoiler: they were right.) I chose to jump back in because my first conversation with the hiring manager left a strong impression in the best way. After experiencing some truly damaging leadership in my last role, I knew I couldn’t afford to compromise on that again.

Ok, So WTH Is LocalStack?

If you work with cloud technologies and haven’t heard of LocalStack yet, you might be missing one of the best kept secrets in cloud development. LocalStack isn’t just a cloud emulator, it’s the cloud emulator.

It lets developers spin up a fully functional local AWS cloud environment, test serverless apps offline, run CI pipelines faster, and catch bugs before they ever hit prod, all without racking up a massive cloud bill. They’re leading the space in a way that’s genuinely exciting, and what sealed the deal for me was the team.

The team at LocalStack came highly recommended, and not in that “uh oh” kind of way. From my first conversations, it was clear this was a group of folks who value curiosity, collaboration, and letting people do their best work. I got the sense right away that this was an environment where people are given the space to thrive, not just execute. After what I went through in my last role, that kind of culture was non-negotiable for me.

Community is the Motive

Sure, you’ll see my face on the YouTube channel and catch my name on the blog, social media, and all the usual DevRel-y things, but my main focus goes deeper than just creating content. I’ll be working on activating and engaging the LocalStack community in meaningful ways: sparking conversations, supporting developers as they build, and making it easier for folks to share what they’ve created. Community isn’t just a side task, it’s the core of what I’m here to help grow.

Parting Thoughts

If you’re in the middle of a job search, especially if you’re recovering from a toxic work environment, I see you. Keep going. The right fit is out there.

And if you ever want to talk DevRel, cloud, or just vent about the job hunt, I’m around on the interwebs on Twitter and LinkedIn

Who Needs Roles Anymore? Introducing OpenFGA, the Future of SaaS

Kiah Imani 🇧🇧 — Tue, 14 Jan 2025 22:31:09 +0000

Ever felt like you’re performing a circus act when dealing with user permissions in your saas app? Don’t worry, you’re not alone. Traditional Role-Based Access Control (RBAC) might have been fine when your biggest concern was “Admin vs. Viewer,” but most applications are a lot more complex than that. Think Slack, Notion, or GitHub where access isn’t just about having a certain title, but about belonging to specific teams, organizations, or projects (sometimes all at once).
That’s where OpenFGA takes the stage with a pretty dope concept called Relationship-Based Access Control (ReBAC). Say goodbye to a million static roles and hello to a system that actually understands how humans (and their projects) really work.

Why RBAC Feels Like Ancient History

Let’s be forreal: RBAC basically lumps permissions into neat little buckets (Admin, Editor, Viewer). Which sounds great until you realize you need 14 variations of “Editor” just to handle all the unique scenarios in your multi-tenant saas app. Orgs have complicated hierarchies. Projects sometimes have external contributors who need limited access. And that’s just Monday.
Pretty soon, you’re drowning in roles: JuniorEditor, SeniorEditor, Project123Editor, TemporaryExternalEditorButOnlySometimes. Every time someone changes teams or gets hired as a contractor, you’re stuck juggling roles again. Yikes!

Meet ReBAC: Because It’s All About Relationships

Rather than forcing people into a static label, Relationship-Based Access Control says, “Hey, let’s base access on who’s related to what.” Is Bob the owner of Project Alpha? Great, give him full reign. Is Alice a viewer of that project’s design doc? Sure, let her see it but not edit it. Once Bob leaves the project, you just remove that single relationship no need to break out the chainsaw on your entire role structure.
Key Idea: Relationships > Roles
Owner of a project
Member of an organization
Viewer of a specific document
Collaborator on a task
In ReBAC, these relationships are front and center. It’s like creating a spiderweb of connections when one strand changes, you just tweak that strand.

OpenFGA: Putting Fine-Grained Authorization to Work

OpenFGA is an open-source tool that brings ReBAC to life. It’s built to handle scale, performance, and an ever-growing list of complicated relationships without making you tear your hair out.
Example Time: A Multi-Tenant Collaboration Platform

-Organizations & Teams

user:alice -> member -> organization:acme
team:design -> belongs_to -> organization:acme
user:bob -> member -> team:design

-Translation: Alice is in Acme Org, Bob’s in the Design Team. Instant clarity. No “AcmeDesignTeamAdminJunior” roles needed.

-Projects

user:alice -> owner -> project:website-redesign
team:design -> owner -> project:logo-revamp
user:bob -> collaborator -> project:website-redesign

Now, if Alice wants Bob’s help on the website redesign, she just sets him up as a collaborator. Easy, right?

-Documents

user:alice -> viewer -> document:wireframes
user:bob -> editor -> document:wireframes

If Bob moves to a different project, just remove that relationship. No fuss, no re-labeling.

Why ReBAC (and OpenFGA) Win in the Real World

- Granular control minus the headaches
Each resource is guarded by relationships. Want to keep tight control? Just specify the exact relationship needed.
Dynamic updates
If Bob leaves Team Design, you just remove “member -> team:design.” Instantly, Bob’s out. No rummaging through role definitions.

- Cleaner maintenance
Fewer roles mean fewer migraines. Your business logic evolves, and your relationships update accordingly. No dusty policy docs to maintain.

- Better Security
By focusing on specific relationships, you’re less likely to give out blanket permissions. Fine-grained is safer.

Bringing It All Together

If you’ve ever banged your head against a desk over RBAC, you know it can turn messy fast. Especially in multi-tenant apps, where “Admin” can mean 20 different things. By switching to a relationship-based approach with OpenFGA, you align your access model to how real humans actually operate. That means no more monstrous role spreadsheets, no more “this is how it’s always been,” and definitely more time to build your product.

Parting Thoughts

It’s 2025 y’all, time to retire that ancient, one-size-fits-all approach. OpenFGA gives you the flexibility to handle complex user relationships with elegance. Whether you’re cooking up the next Slack, managing external contractors, or just tired of editing roles for your friends named Bob, ReBAC can save you from permissions purgatory.

And if you want to learn more about exactly how to make this happen, come check out my talk on OpenFGA at NDC Security in Oslo on Thursday, 23 Jan. I’ll be talking about how to model ReBAC for real-world projects. Your future self (and your users) will send you a virtual fist bump.

Here's What’s New in .NET 9!

Kiah Imani 🇧🇧 — Sat, 11 Jan 2025 02:53:40 +0000

TL;DR: .NET 9 is like a phone upgrade. Better battery, improved performance, but no mind-blowing features. That’s okay, though! The past few versions have already handled a lot of heavy lifting.

Biggest bummer? Implicit extension types (the feature that could’ve really changed how we write code) got pulled from C# 13. Guess we’ll have to wait for the next drop. 😔

Now, let’s talk about the cool stuff!

LINQ Upgrades

LINQ Index: Want to loop through a collection and keep track of indexes? .NET 9 makes it simple:

var fruits = new List<string> { "Apple", "Banana", "Cherry" };

foreach (var (index, fruit) in fruits.Index()) {
    Console.WriteLine($"{index + 1}: {fruit}");
}

✨ Output:

1: Apple  
2: Banana  
3: Cherry

LINQ CountBy: Counting items just got easier!

var pets = new List<string> { "Dog", "Cat", "Dog", "Bird" };

foreach (var count in pets.CountBy(p => p)) {
    Console.WriteLine($"There are {count.Value} {count.Key}s.");
}

✨ Output:


There are 2 Dogs.  
There are 1 Cat.  
There are 1 Bird.

Let's just ignore the fact that in some of these cases, 'are' should be 'is'.

LINQ AggregateBy:

Need to calculate totals? AggregateBy has your back:

var orders = new List<(string Customer, int Amount)> {
    ("Alice", 50), ("Alice", 30), ("Bob", 20)
};

foreach (var total in orders.AggregateBy(o => o.Customer, 0, (sum, o) => sum + o.Amount)) {
    Console.WriteLine($"{total.Key} spent a total of ${total.Value}.");
}

✨ Output:

Alice spent a total of $80.  
Bob spent a total of $20.

UUID Version 7

Need GUIDs that play nice with database indexes? Version 7 GUIDs are here for you:

var id = Guid.CreateVersion7();
Console.WriteLine(id);

These sequential GUIDs make querying in databases faster. 🚀

Base Class Library Updates

HTTP/3 and QUIC
HTTP/3 is the hot new thing, and it’s enabled by default in .NET 9. 🌟
Here’s what you need to know:

HttpClient supports HTTP/3 if your system has MsQuic ready to roll.
Kestrel in ASP.NET Core? Fully on board.
IIS? Works with Windows Server 2022 if you’ve got TLS 1.3 configured and registry settings updated.
🤔 But heads up: If you’re using Visual Studio’s default HTTPS certs, browsers won’t play nice with HTTP/3. Keep that in mind when testing!

Lock

.NET 9 introduces a new Lock type that’s more efficient and future-ready:

private readonly Lock syncLock = new();

void UpdateInventory() {
    lock (syncLock) {
        // Thread-safe updates here
    }
}

No more worrying about making your lock logic future-proof!

What’s New in C# 13?

Implicit Index Access

Initialize arrays with reverse indexing, effortlessly:

var secretCode = new byte[4] {
    [^1] = 0x42, 
    [^2] = 0x37,
    [^3] = 0x29, 
    [^4] = 0x18
};

Boom—values set in reverse, no extra steps.

What’s New in ASP.NET Core 9?

Hybrid Cache

In-process and out-of-process caching? Yes, please.

builder.Services.AddHybridCache();

public async Task<string> GetDataAsync(string key) {
    return await hybridCache.GetOrCreateAsync(key, async entry => {
        await Task.Delay(100); // Fake fetch  
        return "Cached Result";
    });
}

Avoid cache stampedes like a pro.

MapStaticAssets

Forget manually handling static files—.NET 9 optimizes this for you.

app.MapStaticAssets();

Why it’s 🔥: Automatically calculated hashes (ETags) for files mean better caching. Your CI/CD pipeline says thank you.

Wrapping Up

.NET 9 may not have jaw-dropping new features, but it’s leveling up performance and usability in subtle, powerful ways. Think of it like a fine-tuned engine—ready to take your apps even further.

If you’re hyped (or just curious), let me know! Drop a comment, share your favorite features, or hit me with your best dev memes.

Let’s Keep Building Together!

Love geeking out about .NET, dev tips, or the latest in tech? Head to my site at blkgrlcto.com for updates and resources, and follow me on Twitter to stay in the loop. Let’s keep the innovation going and shape the future of development together! 🚀

Exploring The Southeast's Last Vibrant Tech Scene: ATL Meetup Tour

Kiah Imani 🇧🇧 — Wed, 08 Jan 2025 16:59:49 +0000

Fall 2024, I decided to touch the road and check out some of Atlanta’s tech meetups. Since moving to the metro area in September, one of my main goals has been to dive head first into the local tech scene. I want to meet dope people, get active, and find ways to contribute. Atlanta’s tech community is full of dope people building amazing things, and I’m here to experience that energy firsthand.
This tour is all about showing up, being part of the conversation, and seeing how I can help out. Whether it’s jumping into a hands-on activity, sharing ideas, or just hyping up the awesome work others are doing, I’m here for it. No agenda, no strings attached, just showing up and seeing where the vibes align.

Here’s a recap of where I’ve been so far:

Refactr.Tech Code Jam (October 10):
The first stop was Refactr.Tech’s Hacktoberfest-themed Code Jam. About 15 developers showed up, and the focus was all on open-source contributions. I shared a few open-source resources and had some great chats with the organizers, Angel Banks, Erica Stanley, and Beth Liang. These ladies are on a mission to create inclusive, hands-on events, and it shows. They’ve got big plans for more talk-focused meetups next year and even a conference in the future. Can’t wait to see what they do next!

DC404 Hybrid Meetup (October 19):
This one was a mix of in-person and online at Manuel’s Tavern, and it worked! (Well, except for a couple of tech hiccups, but hey, that’s life.) The talk of the night, Hacking Your CISO, was super engaging, and the project “show-and-tell” was a fun way for attendees to share their work. Then we got into a NetKotH CTF session, which was basically a hands-on hacking challenge. The whole night had a collaborative vibe that made it really stand out.

OWASP Atlanta Meetup - The State of Secure Code + Tournament (October 23):
Next up was OWASP Atlanta at FanDuel’s office. About 30 people came out for a deep dive into secure coding practices, followed by a Secure Coding Tournament. It was a perfect mix of learning and doing. I also had a great chat with the organizer, Guled Abdilahi, about ways to make future meetups even better, whether that’s through workshops, speaking opportunities, or other collaborations.

What’s Next?
So far, this tour has been such a great experience. Each meetup has its own personality, and I’ve met so many inspiring people. I’m looking forward to checking out even more events and finding new ways to support Atlanta’s tech community.
If you know of a meetup I should check out, hit me up! Let’s keep building these connections and making the Atlanta tech scene even stronger.

Event Recap: Major League Hacking Global Hack Week – Open Source

Kiah Imani 🇧🇧 — Wed, 08 Jan 2025 16:51:14 +0000

Where: Virtual (streamed live on MLH’s YouTube and Twitch)
When: September 29 – October 1
Who: College students from around the world

What Went Down
Major League Hacking’s Global Hack Week – Open Source brought together college students from across the globe for a virtual series of talks and events. With a lively chat on both YouTube and Twitch, the event created an interactive space to dive into key tech concepts while celebrating open-source innovation.

My Talk: Identity 101
I delivered a talk called Identity 101, breaking down the fundamentals of identity with a Gen Z-friendly twist. Using relatable stories and pop culture references, I kept the tone fun and approachable, making sure the ideas stuck without feeling heavy or overly technical.

The live chat was buzzing with a few attendees jumping in to ask questions and share their thoughts. After the talk, I connected with some of them on Twitter, where we continued the conversation and explored more identity related topics.

What Made it Dope
Global Hack Week Open Source was an incredible platform to connect with a young, global audience passionate about tech and open source. It wasn’t just about sharing knowledge—it was about sparking real conversations and building lasting connections that extended beyond the event.

Let’s Stay Connected!
Interested in more talks, insights, or open-source fun? Head over to blkgrlcto.com for updates, and follow me on Twitter to keep the conversation going. Let’s build the future of tech together!

Event Recap: OWASP Atlanta Meetup – The State of Secure Code + Tournament

Kiah Imani 🇧🇧 — Wed, 08 Jan 2025 16:42:40 +0000

When: October 23
Where: FanDuel
Who: About 30 techies

What Went Down
On October 23, OWASP Atlanta hosted a meetup focused on the state of secure coding practices. Around 30 attendees gathered at the FanDuel office to hear from Michael Burch, Director of Application Security at Security Journey, and Chrissy Herman, an Enterprise Account Executive with the same company.

The presentation explored the challenges of secure coding, highlighting the impact of growing software complexity and an ever-evolving threat landscape. Key topics included integrating security into the software development lifecycle, addressing common vulnerabilities, and the importance of ongoing collaboration and education between developers and security professionals.

Secure Coding Tournament
After the talk, the meetup switched gears with a Secure Coding Tournament, giving attendees a chance to get hands-on with the concepts discussed earlier. The competitive format brought a lot of energy to the room while reinforcing the importance of applying secure coding practices in real-world scenarios.

Networking Highlights
I had the chance to connect with the event organizer, Guled Abdilahi, and discuss future opportunities to collaborate. We brainstormed ideas for speaking engagements, workshops, and even sponsorships, and Guled seemed excited about the possibilities. He promised to share more details soon, so there’s definitely potential to build something great here.

What Made It Dope
This meetup was a great mix of education, hands-on learning, and networking. It drove home the importance of secure coding practices and showcased how events like these can foster collaboration between the cybersecurity and developer communities.

Let’s Connect!
Want to hear more about events like this or dive into secure coding and tech trends? Check out blkgrlcto.com and follow me on Twitter to stay connected. Let’s keep building secure software together!

Event Recap: Refactr.Tech Code Jam Meetup – Hacktoberfest Edition

Kiah Imani 🇧🇧 — Wed, 08 Jan 2025 15:45:42 +0000

When: October 10
Where: Coda @ Tech Square
Who: About 15 web developers

What Went Down
On October 10, I joined the Refactr.Tech Code Jam meetup, a Hacktoberfest-themed gathering that brought together about 15 developers ready to dive into discussions about open-source contributions. While no actual coding happened during the event, it was a great space for sharing ideas, exploring resources, and connecting with folks passionate about growing their skills in open source.

Spreading the Word About Authtoberfest
I took the chance to introduce Auth0's Authtoberfest, highlighting how contributors could earn some cool incentives for focusing on authentication and security projects. This sparked interest among a few attendees who were eager to learn more about tackling auth challenges and leveling up their open-source game.
Connecting with Refactr.Tech Organizers
One of the best parts of the evening was chatting with the Refactr.Tech crew Angel Banks, Erica Stanley, and Beth Liang. We brainstormed potential collaborations and talked about their exciting plans for 2025. They’re shifting gears toward more talk-focused meetups starting in the new year and have a conference in the works. Plenty of synergy here to explore!

What Made It Dope
This meetup wasn’t about writing code—it was about building connections, sharing insights, and creating a collaborative space for developers to feel inspired and supported. The intimate vibe and shared enthusiasm for open source made it a meaningful event.

Let’s Connect!
Want to keep up with more events and open-source insights? Visit blkgrlcto.com for updates, or follow me on Twitter to stay in the loop. Let’s keep the conversation going!

Event Recap: SOSS: Fusion Conference

Kiah Imani 🇧🇧 — Wed, 08 Jan 2025 06:01:36 +0000

When: October 23-24
Where: Atlanta, GA
Who: A couple hundred OSS nerds

What Went Down
The SOSS: Fusion Conference, put on by OpenSSF, was all about bringing folks together to tackle open-source security head on. Picture software devs, security engineers, tech leaders, and public-sector pros all gathering in one space. Topics ranged from AI security and diversity to open-source public policy. The goal? Get a mix of perspectives and brainstorm real solutions to some of the toughest challenges in securing open-source software.

My Talk: Let’s Rethink Access Control
On October 23, I stepped up to deliver my talk, "Role-Based Access Is So Yesterday: Revolutionizing Access Control with OpenFGA." It was the last talk before the keynote, so I knew I had to keep the energy up, and I did! About 20 folks joined, and the engagement was 🔥, especially when I demoed the FGA Playground. It turned into a cool conversation about how modern access control can really change the game.

Why This Event Stands Out
This wasn’t your typical big conference chaos. It had a chill, intimate vibe that made it easy to dive into real conversations with people who actually care about solving open source security issues. If there’s a chance to sponsor this under a brand like OpenFGA in the future, I’d say go for it. The focused audience means quality over quantity when it comes to connections.

The Takeaway
SOSS: Fusion nailed it, mixing solid knowledge sharing with some legit networking. It was all about collaboration and making moves to secure open source.

Let's Stay Connected
If you're into more tech insights and updates, check out my website at blkgrlcto.com and follow me on Twitter to stay in the loop! Let's keep the conversation going.