DEV Community: Chellappan

Getting Started with ThunderID: A Beginner's Guide to Modern Identity Management ⚡

Chellappan — Thu, 02 Jul 2026 04:11:07 +0000

Introduction

Have you ever wondered how apps keep your information safe and control what you can access? That's where Identity and Access Management (IAM) comes in. And today, we're exploring ThunderID — an exciting, modern IAM platform that's perfect for beginners to understand!

ThunderID is a lightweight, open-source Identity and Access Management engine designed for the modern era where AI agents and humans work together. Whether you're securing applications, protecting APIs, or managing access for AI-driven workflows, ThunderID has you covered.

Learn more at the ThunderID website.

What Makes ThunderID Special? 🌟

ThunderID stands out because it's built with four core design goals in mind:

1. Agent-Native Identity

In today's world, AI agents aren't just tools—they're becoming first-class citizens in our digital ecosystems. ThunderID treats AI agents with the same importance as humans, letting you manage them with delegated authority, track their actions, and even issue verifiable credentials to them.

2. Decentralized Identity

Imagine digital wallets that work everywhere, even across different services. ThunderID bridges this gap, making it practical for organizations to trust and verify decentralized identities in real-world applications.

3. Cloud-Native IAM

Whether you're running systems on-premises or in the cloud, ThunderID adapts to your needs. It's lightweight, containerized, and uses declarative configuration—meaning you can define your identity flows as code!

4. Post-Quantum-Safe Security

Security is always evolving. ThunderID is built with a crypto-agile foundation, meaning it can adapt to future security standards, including post-quantum cryptography.

Core Features Explained Simply 🎯

Identity Management

Manages humans, AI agents, and machines as different identity types
Organizes identities into hierarchical groups and organizational units (OUs)

Authentication Standards

OAuth 2.1 and OpenID Connect for secure login
WebAuthn/Passkeys for password-less security
IdP Federation — connect with Google, Microsoft, GitHub, and more

Verifiable Credentials

ThunderID can issue digital credentials that prove who you are—think of them as digital certificates that travel with you! Features include:

OpenID4VCI (issuance) - issue credentials to user wallets
OpenID4VP (verification) - verify presented credentials
Configurable credential templates
Integration with identity journeys

User Journeys

Defines flexible login and registration flows using 20+ built-in executors like:

Password-based login
Passkeys
One-Time Passwords (OTP)
Social login (Google, GitHub, etc.)
Consent management
Themeable end-user UI
Orchestratable in server or application

Authorization & Access Control

Role-Based Access Control (RBAC) — assign roles and manage permissions
Hierarchical Resources — organize what users can access with derived permissions
Consent Management — users can review and approve what access they're granting

Developer Experience

Console UI for visual management
REST APIs for programmatic control
SDKs for easy integration
MCP Server for managing and querying IAM from AI agents

Declarative & GitOps-Ready

YAML resource definitions for every entity
Immutable runtime for consistency
Infrastructure as code friendly

Getting Started with ThunderID 🚀

ThunderID makes it easy to get started with three main use cases:

1. Securing B2C Applications

Want to add secure login to your web or mobile app? Follow the Securing B2C Application Guide to learn how.

2. Securing AI Agents

Building AI-powered systems? Check out the Securing AI Agents Guide to manage agent access securely.

3. Securing MCP (Model Context Protocol)

For advanced AI integrations, explore the Securing MCP Guide.

To dive deeper into architecture and patterns, visit the Use Cases Overview.

For detailed installation and setup, check the Get ThunderID Guide.

Architecture Overview 🏗️

ThunderID is architected to be modular, scalable, and easy to deploy. The system separates concerns into different components, making it flexible for various deployment scenarios—from single-server setups to distributed cloud environments.

The backend is built with Go, providing excellent performance and reliability. For detailed architecture information, check the ThunderID Documentation and SDK Documentation.

Why Should You Care? 💡

Whether you're a:

Developer building secure applications
DevOps Engineer managing infrastructure
Security Professional implementing IAM solutions
Student learning about modern identity systems
AI/ML Engineer building agent-driven workflows

ThunderID provides a practical, modern, and open-source solution that's easy to understand and deploy.

Key Features at a Glance ✨

Feature	Benefit
Humans, Agents & Machines	Manage all identity types in one platform
OAuth 2.1 & OpenID Connect	Industry-standard authentication protocols
WebAuthn/Passkeys	Password-less, more secure authentication
Verifiable Credentials	Portable, trustworthy digital credentials
20+ Built-in Executors	Flexible authentication flows out of the box
RBAC & Consent Management	Fine-grained access control
REST APIs & SDKs	Easy integration into your applications
Declarative Configuration	GitOps-ready infrastructure
Post-Quantum Safe	Future-proof security foundation
MCP Server Support	Native AI agent management

Real-World Applications 🌍

For Web & Mobile Apps

Implement secure authentication without building everything from scratch. Use ThunderID to add social login, passkeys, and OTP to your applications.

For AI-Powered Services

As AI agents become more autonomous, they need proper identity and authorization. ThunderID lets you grant controlled permissions to AI agents while maintaining complete traceability.

For Enterprise Systems

Manage complex organizational hierarchies, implement fine-grained access controls, and maintain comprehensive audit trails across all your systems.

For Privacy-Conscious Organizations

Issue verifiable credentials that put users in control of their identity data, reducing your organization's liability while maintaining security.

Getting Involved 🤝

ThunderID is open-source and welcomes contributions from the community! Here's how you can get involved:

Contribute Code: Follow the Contributing Code Guide to get started
Report Issues: Found a bug? Head to the GitHub Issues page
Join the Community: Visit the Community Overview to connect with other contributors
Star the Repository: Show your support on GitHub

Next Steps 📚

Visit ThunderID.dev to explore the platform
Check out the Getting Started Guide
Review the Contributing Guide to get involved
Star the GitHub Repository to support the project
Explore SDK Documentation for your preferred language

Key Takeaways ✅

ThunderID is a modern, lightweight IAM engine for humans, AI agents, and machines
It supports industry standards like OAuth 2.1, OpenID Connect, and WebAuthn
It's designed to be cloud-native, decentralized, and future-proof
It's open-source, developer-friendly, and easy to get started with
Perfect for the agentic era where AI and humans work together seamlessly
Built on a crypto-agile foundation ready for post-quantum cryptography

Learn More 📖

For comprehensive guides and documentation, visit:

Ready to explore ThunderID? Head over to thunderid.dev and start securing your applications today! ⚡

Happy learning! 🎉

The False Sense of Progress in learning

Chellappan — Mon, 05 May 2025 11:55:07 +0000

When learning programming or data structures, it’s easy to feel like we're making significant progress just by spending a lot of time coding or watching tutorials. We might think that by solving numerous problems or watching endless videos, we are improving our skills. However, after a certain point, we might find ourselves struggling to solve problems we’ve encountered before or feel stuck when faced with new challenges. This is the false sense of progress that many learners experience in their programming journey.

The Illusion of Progress

At the beginning of learning programming, it’s common to feel like we are advancing rapidly. Solving coding problems and watching tutorials can give us the impression that we're progressing. But when it comes to solving more complex problems or applying what we've learned to real-world scenarios, we can struggle. The reality is, while we may be spending time coding or watching tutorials, we might not be gaining the deep understanding necessary to solve more advanced problems effectively.

For example, solving the same type of problem repeatedly or using a tool like ChatGPT for answers without understanding the process can give the illusion of progress. But when it comes to tackling new problems or applying our knowledge in a different context, we find ourselves unable to move forward.

Why It Happens

Memorizing Solutions Without Understanding:
Watching tutorials or solving similar problems repeatedly can lead to memorizing solutions without fully understanding the underlying concepts. This approach doesn’t help when facing unfamiliar or complex challenges.
Focusing on Quantity Over Quality:
It’s easy to fall into the trap of solving many problems without paying attention to the quality of learning. While completing lots of tasks might seem like progress, without understanding the reasoning behind the solutions, we won’t be able to apply our knowledge effectively to new challenges.
Relying Too Much on External Help:
Relying on tools like ChatGPT or copying solutions from online resources without fully understanding them can hinder our progress. While external help can be useful, solving problems on our own and understanding the logic behind the solution is crucial for deeper learning.

How to Avoid This Trap

Focus on Understanding, Not Just Completing Tasks:
Instead of just solving problems for the sake of completion, take the time to understand the concepts and reasoning behind the solution. Ask yourself why the solution works and how it can be improved or applied in different scenarios.
Learn Concepts, Not Just Solutions:
Don’t just solve random problems. Choose a specific concept (e.g., algorithms, data structures, design patterns) and focus on solving problems related to it. This focused approach helps you build a solid foundation before moving on to more advanced topics.
Learn Patterns, Not Just Memorize Solutions:
Instead of memorizing specific solutions, try to learn the patterns or strategies behind them. For instance, understand the common patterns like recursion, sliding window, or dynamic programming. Recognizing these patterns in new problems will make problem-solving more efficient.
Challenge Yourself with New Problems:
Once you’ve solved a set of similar problems, try to solve new problems that test your understanding in different ways. Challenge yourself with problems that require you to think critically and apply what you’ve learned to new situations.
Reflect on Your Mistakes:
After solving problems, especially those you struggled with, spend time analyzing your mistakes. Why did you fail? What was your thought process? Reflection helps you identify areas for improvement and build a deeper understanding of the material.
Use External Help Effectively:
External resources, like tutorials or AI tools, can be helpful for guidance. However, always try to solve the problem on your own first. Use external help to clarify concepts afterward, but make sure you understand the solution deeply before moving forward.

Conclusion

While it's tempting to solve many problems quickly or consume a lot of tutorials, it’s more important to focus on understanding the concepts and reasoning behind them. Prioritize quality learning over quantity, and work on developing a solid foundation in programming. By focusing on patterns and concepts, and reflecting on your progress, you'll make meaningful strides in improving your programming skills and be better prepared for more complex challenges ahead.

How to create New Angular App Without Global CLI Installation

Chellappan — Fri, 12 Jan 2024 09:27:46 +0000

Hello fellow developers! Today, I'm excited to share a quick and efficient way to create a new Angular application without the need to install Angular CLI globally on your machine. This approach is perfect for those who prefer to avoid global installations or are working with multiple versions of Angular. Let’s dive in!

The Magic Command:

npx @angular/cli@next new <app-name>

The command npx @angular/cli@next new <app-name> is a one-liner that packs a punch.

Here’s a breakdown:

npx: A package runner tool that comes with npm 5.2+.

@angular/cli@next: This specifies the Angular CLI package. The @next tag fetches the latest pre-release version. If you prefer the stable version, just use @angular/cli.

new demo-app: This part of the command tells Angular CLI to create a new project named demo-app.