Coder Legion - Recent posts tagged studentsuccess

AWS: IAM, Regions, Availability Zones, and the Shared Responsibility Model

Tue, 06 Oct 2026 13:20:33 +0000

AWS: IAM, Regions, Availability Zones, and the Shared Responsibility Model

A Practical Beginner's Guide with Certification Mapping (SAA / MLA-C02 / Professional Foundations)

The Beginner Problem

One of the most common mistakes new AWS users make is launching resources before understanding three foundational concepts:

Who is allowed to do something? → IAM
Where are resources running? → Regions and Availability Zones
Who is responsible for security? → Shared Responsibility Model

A beginner might create an EC2 instance, upload files to Amazon S3, and then realize:

They accidentally used administrator permissions everywhere.
They deployed resources in the wrong Region.
They assumed AWS automatically backs up or secures everything.
They cannot find a resource because they're viewing a different Region.

These mistakes appear simple, but they are exactly the type of concepts tested heavily in:

AWS Certified Solutions Architect – Associate (SAA)
AWS Certified Machine Learning Engineer – Associate (MLA-C02)
AWS Professional-level architecture and security domains

In this hands-on article, you'll build foundational AWS knowledge through practical implementation instead of memorization.

Learning Objectives

By the end of this exercise you should understand:

IAM users, groups, permissions, and policies
Least privilege access
AWS Regions and Availability Zones (AZs)
High availability fundamentals
AWS Shared Responsibility Model
AWS account security best practices
How these concepts fit into real cloud architectures

Where These Concepts Fit in Real Architecture

Before opening the console, it helps to understand where these concepts fit.

A simple AWS application may look like this:

User
   |
   v
IAM Authentication & Authorization
   |
   v
VPC
   |
   +---- EC2 Instance (AZ-A)
   |
   +---- EC2 Instance (AZ-B)
   |
   +---- Amazon S3 Bucket
   |
   +---- RDS Database

Architecture Diagram Description

Create an architecture image containing:

One AWS Region
Two Availability Zones within that Region
One EC2 instance in each Availability Zone
One Amazon S3 bucket shared across the Region
One IAM user accessing AWS services
Labels showing:
- IAM controls access
- AZs improve availability
- Regions determine geographic placement
- AWS and customer share security responsibilities

Understanding IAM

What Is IAM?

AWS Identity and Access Management (IAM) is the AWS service used to control who can access AWS resources and what actions they can perform.

Think of IAM as the security guard for your AWS account.

IAM answers three questions:

Who are you?
What resources can you access?
What actions are you allowed to perform?

Without IAM, every user would effectively have administrator permissions, which creates major security risks.

Real-World Example

Imagine a startup team:

Team Member	Access Needed
Developer	Amazon EC2
Data Analyst	Amazon S3
Security Engineer	IAM
Intern	Read-only access

Giving all of them AdministratorAccess would violate AWS security best practices.

Instead, IAM allows organizations to grant only the permissions required for each role. This principle is known as least privilege.

Understanding Regions and Availability Zones

AWS infrastructure is organized into Regions and Availability Zones.

These concepts are frequently tested in AWS certification exams because they directly affect:

Availability
Resilience
Disaster recovery
Compliance
Cost management

What Is a Region?

A Region is a geographic AWS location.

Examples include:

US East (N. Virginia)
US East (Ohio)
Europe (Frankfurt)
Asia Pacific (Mumbai)

When selecting a Region, consider:

User location
Regulatory requirements
Available AWS services
Latency requirements

Example

If your customers are primarily in Pakistan and India, you may choose:

ap-south-1 (Mumbai)

to reduce latency compared to a North American Region.

What Is an Availability Zone?

An Availability Zone (AZ) is an isolated AWS facility within a Region.

Examples:

us-east-1a
us-east-1b
us-east-1c

Each Availability Zone is designed to operate independently.

If one Availability Zone experiences problems:

Applications running in another AZ may continue operating.
High availability architectures remain functional.

Why Multiple Availability Zones Matter

Single-AZ deployment:

EC2
 |
AZ-A

If AZ-A fails:

Application Unavailable

Multi-AZ deployment:

EC2 (AZ-A)
     |
Load Balancer
     |
EC2 (AZ-B)

If one AZ fails:

Traffic continues through surviving AZ

This is a core AWS high-availability pattern.

Understanding the Shared Responsibility Model

One of the most important AWS concepts is understanding who is responsible for what.

Many beginners incorrectly assume:

“AWS manages security, so I'm automatically protected.”

This is false.

AWS security follows a Shared Responsibility Model.

AWS Responsibilities

AWS is responsible for security OF the cloud, including:

Physical data centers
Physical network infrastructure
Power systems
Cooling systems
Hardware
Virtualization infrastructure

AWS manages and protects the underlying cloud infrastructure.

Customer Responsibilities

Customers are responsible for security IN the cloud, including:

IAM permissions
User management
Data protection
Application security
Operating system patching on EC2
Security Groups
Encryption configuration

Certification Exam Example

Question:

An EC2 instance is compromised because security updates were never installed.

Who is responsible?

Answer: Customer

Reason:

For Amazon EC2, customers are responsible for managing and patching the guest operating system.

Prerequisites

Before beginning:

AWS account
Access to AWS Management Console
MFA enabled on the root account (recommended)
Modern web browser
Basic cloud computing familiarity

Important: AWS updates the console regularly. If your interface differs from the screenshots or instructions shown here, verify the latest workflow using the official AWS documentation.

Hands-On Lab

Part 1: Create an IAM User

Certification Concepts

SAA

Identity and Access Management
Security Best Practices
Least Privilege

MLA-C02

Secure access to machine learning resources

Step 1: Open IAM

Navigate to:

AWS Console
→ IAM
→ Users

Why This Step Matters

Users represent individual human identities.

AWS recommends avoiding daily use of the root account.

Step 2: Create a New User

Select:

Create User

Example username:

student-user

Enable:

Provide user access to AWS Management Console

Why This Option Matters

This creates a separate identity rather than sharing root credentials.

This follows AWS security best practices.

Step 3: Assign Permissions

Choose:

Attach policies directly

Select:

ReadOnlyAccess

Why This Policy?

ReadOnlyAccess allows a user to:

View resources
Explore the account
Learn AWS safely

It prevents:

Resource deletion
Infrastructure modification
Administrative changes

This demonstrates least privilege access.

Step 4: Review and Create

Review:

Username
Console access
Attached permissions

Click:

Create User

Save:

Sign-in URL
Username

You will use them later for testing.

Part 2: Explore AWS Regions

Certification Concepts

SAA

Global Infrastructure
Regional Design
Workload Placement

Step 1: Locate the Region Selector

In the AWS Console, locate the Region selector in the upper-right corner.

Examples:

us-east-1
us-west-2
eu-west-1
ap-south-1

Step 2: Switch Between Regions

Move from one Region to another.

Observe:

EC2 instance lists change
VPC configurations change
Resource inventories change

Key Lesson

Most AWS resources are Regional.

Resources created in one Region do not automatically appear in another Region.

Part 3: Explore Availability Zones

Certification Concepts

SAA

Fault Tolerance
Availability
Resilience Design

Step 1: Open EC2

Navigate to:

EC2
→ Launch Instance

You do not need to launch an instance.

You are only exploring the configuration options.

Step 2: Review Network Placement

Locate:

Availability Zone

Examples:

us-east-1a
us-east-1b
us-east-1c

Why This Matters

Workloads distributed across multiple Availability Zones are more resilient than workloads running in a single AZ.

This principle is used heavily in production architectures.

Part 4: Apply the Shared Responsibility Model

Certification Concepts

SAA

Security Design
Operational Excellence

Professional Certifications

Governance
Risk Management
Compliance

Scenario

You launch:

Amazon EC2

Now ask:

Who secures what?

AWS Secures

Physical servers
Network facilities
Storage hardware
Data center operations

You Secure

Application code
IAM permissions
Operating system updates
Security Groups
Credentials
Data access controls

Validation and Testing

Expected Result:

Login succeeds

Test 2: Attempt Administrative Actions

Attempt:

Create a new IAM policy

Expected Result:

Access Denied

Reason:

ReadOnlyAccess does not permit administrative changes.

Test 3: Switch Regions

Move between Regions.

Expected Result:

Different resources appear

Test 4: Identify Availability Zones

Locate at least two AZs within your selected Region.

Expected Result:

Multiple AZs available

Test 5: Shared Responsibility Review

For an EC2 deployment, identify customer responsibilities.

Expected Answers:

IAM configuration
Operating system patching
Security Group configuration

Troubleshooting

Case 1: Resources Cannot Be Found

Cause

Wrong Region selected.

Fix

Verify the Region selector.

Case 2: Access Denied Errors

Cause

IAM policy lacks required permissions.

Fix

Review attached policies and permissions.

Cause

Console access was not enabled during user creation.

Fix

Edit the user settings and enable console access.

Case 4: Using Root Account for Everything

Cause

Common beginner mistake.

Fix

Create IAM users for daily activities.

Enable MFA on the root account.

Case 5: Assuming AWS Configures Security Automatically

Cause

Misunderstanding Shared Responsibility.

Fix

Review which responsibilities belong to AWS and which belong to customers.

Security Considerations

Follow these security practices:

Enable MFA on privileged accounts.
Avoid using the root user for routine work.
Apply least privilege permissions.
Remove unused users.
Review permissions regularly.
Use IAM roles where possible.
Protect access keys.
Monitor account activity.

Cost and Free Tier Awareness

This exercise primarily uses informational console activities.

However, always remember:

AWS pricing changes over time.
Free Tier eligibility changes.
Different Regions may have different pricing.

Before launching resources:

Review AWS Pricing
Review AWS Free Tier documentation
Confirm current pricing directly in AWS documentation

Never assume a resource is free because a tutorial says so.

Cleanup

Delete Test IAM User

Navigate to:

IAM
→ Users
→ student-user
→ Delete

Verify Deletion

Confirm:

User no longer exists

Delete Additional Resources

If you launched resources while experimenting, remove:

EC2 Instances
EBS Volumes
Elastic IP Addresses
Load Balancers

Review each service manually to ensure cleanup is complete.

Intermediate Extension Challenge

Create:

Developers Group

Attach:

ReadOnlyAccess

Then:

Create multiple users.
Add users to the group.
Test permissions.

Skills Developed

IAM Groups
Permission Management
Least Privilege at Scale

Advanced / Professional Discussion

At the professional architect level, these concepts become organizational design decisions rather than basic AWS features.

Multi-Account Strategy

Many organizations separate:

Development
Testing
Production

into different AWS accounts.

Benefits:

Better security boundaries
Easier auditing
Reduced operational risk

Multi-Region Architectures

Mission-critical applications often deploy across multiple Regions.

Benefits:

Disaster recovery
Geographic redundancy
Improved global user experience

Advanced IAM

Large organizations frequently adopt:

IAM Roles
Federation
AWS IAM Identity Center
Attribute-Based Access Control (ABAC)

to manage access at scale.

Compliance Considerations

Region selection may be driven by:

Data residency requirements
Regulatory obligations
Customer contracts
Disaster recovery requirements

These considerations commonly appear in AWS architecture certification exams.

References
AWS IAM Documentation: https://docs.aws.amazon.com/iam/
Getting Started with IAM: https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started.html
AWS Regions and Availability Zones: https://docs.aws.amazon.com/global-infrastructure/latest/regions/aws-regions-availability-zones.html
AWS Regions Documentation: https://docs.aws.amazon.com/global-infrastructure/latest/regions/aws-regions.html
AWS Shared Responsibility Model: https://aws.amazon.com/compliance/shared-responsibility-model/

The 2026 Student Tech Stack: What I Would Learn Before Graduation

Mon, 28 Sep 2026 15:38:52 +0000

Every year, I see students asking the same question:

"Which technology should I learn next?"

Python or Java?

Cloud or AI?

Data or DevOps?

Web development or automation?

The problem is not a lack of learning resources. The problem is trying to learn everything at once.

My view is simple:

Students don't need to learn everything. They need a coherent stack that lets them build.

A student who understands programming, uses modern developer tools, knows basic cloud concepts, can work with AI and data, automates repetitive work, validates skills, and participates in a community will usually move much faster than someone who spends years collecting disconnected tutorials.

The goal before graduation is not becoming an expert in every domain.

The goal is becoming capable of building useful things from idea to deployment.

This is the learning stack I would personally focus on in 2026.

1. Programming

Why it matters

Programming is still the foundation.

AI can generate code.

Low-code tools can accelerate development.

Templates can save time.

But none of these replace the ability to understand logic, debug problems, and design solutions.

When projects become even slightly complex, programming remains the skill that allows you to move independently.

I often meet students who jump immediately into advanced frameworks while struggling with basic problem solving. That usually creates frustration later.

Strong fundamentals age much better than trendy technologies.

What level I would target

I would not aim to become a programming-language historian.

Instead, I would target:

One primary language
Data structures and algorithms fundamentals
APIs
File handling
Git-based development
Basic software architecture concepts
Problem-solving confidence

For many students, Python, C#, or Java can serve this role effectively.

The exact language matters less than your ability to build with it.

One practical project

Build a student productivity application.

Examples:

Assignment tracker
Study planner
Expense manager
Event management tool

The project should store data, have authentication, and solve a real problem.

One Microsoft resource worth exploring

Microsoft Learn

https://learn.microsoft.com?wt.mc_id=studentamb_496381

It provides structured learning paths that help students build practical skills rather than simply memorizing syntax.

What I would not waste time learning

Memorizing obscure language features
Endless coding challenge collections without projects
Learning five programming languages simultaneously

You only need one language to become productive.

2. Developer Tools

Why it matters

Many students focus only on coding.

Professional developers spend enormous amounts of time using tools around the code.

Version control.

Debugging tools.

Editors.

Collaboration platforms.

Documentation systems.

The difference between a beginner and a productive builder is often tool proficiency.

A student using modern tooling can build significantly faster than someone fighting their environment every day.

What level I would target

Before graduation, I would be comfortable with:

Git
GitHub
Branches and pull requests
Debugging workflows
Extensions
Terminal basics
Reading logs

These are skills you will use repeatedly regardless of your career path.

One practical project

Create a team project with friends.

Use:

GitHub repository
Issues
Branches
Pull requests
Documentation

This teaches collaboration far better than solo practice.

One Microsoft resource worth exploring

VS Code

Learn how to use it properly rather than simply installing it.

Features like debugging, extensions, integrated terminals, and Git integration can dramatically improve productivity.

What I would not waste time learning

Customizing editors for weeks
Chasing every new extension
Endless comparisons between development environments

Tools should support your work, not become the work.

3. Cloud

Why it matters

Most modern applications eventually live somewhere other than a laptop.

Understanding cloud services helps students understand how software actually reaches users.

Cloud knowledge is no longer reserved for infrastructure specialists.

Developers, data professionals, AI engineers, and founders all benefit from understanding cloud concepts.

What level I would target

I would aim for:

Cloud fundamentals
Virtual machines
Storage
Networking basics
Authentication
Deploying applications
Monitoring fundamentals

You do not need advanced cloud architecture before graduation.

You need enough knowledge to deploy and operate a project.

One practical project

Deploy your student project to the cloud.

Make it accessible through a public URL.

This experience teaches more than dozens of cloud theory videos.

One Microsoft resource worth exploring

Azure for Students

It allows students to experiment with cloud services and gain practical experience building real applications.

You can combine it with learning paths on:

https://learn.microsoft.com?wt.mc_id=studentamb_496381

What I would not waste time learning

Extremely advanced enterprise architectures
Niche certification objectives without hands-on practice
Memorizing cloud service names

Understanding concepts is more valuable than memorizing product catalogs.

4. AI

Why it matters

Ignoring AI in 2026 would be a mistake.

Treating AI as magic would be another mistake.

The students gaining the most advantage are not necessarily building foundation models.

They are learning how to use AI effectively to solve practical problems.

AI is becoming a productivity multiplier.

Students who learn to work with it will often outperform students who either fear it or depend on it completely.

What level I would target

I would focus on:

Prompting fundamentals
Responsible AI concepts
AI-assisted development
Basic AI application development
Retrieval and knowledge-based solutions
Evaluating outputs critically

You do not need a PhD-level understanding of machine learning.

You need enough knowledge to integrate AI into useful projects.

One practical project

Build a study assistant for students.

Possible capabilities:

Question answering
Summarization
Note organization
Resource recommendations

This creates a realistic AI use case that solves an actual problem.

One Microsoft resource worth exploring

Microsoft Copilot

Use it as a learning partner.

Ask it to explain code, review ideas, generate documentation, and suggest improvements.

The goal is not replacing thinking.

The goal is accelerating thinking.

What I would not waste time learning

Every new AI framework
Daily AI hype cycles
Complex research papers far beyond your current goals

Focus on practical application before advanced specialization.

5. Data

Why it matters

Almost every decision today is influenced by data.

Products generate data.

Businesses analyze data.

AI systems rely on data.

Understanding data makes you a better developer, analyst, founder, and problem solver.

I often tell students that data literacy is becoming as important as coding literacy.

What level I would target

I would learn:

SQL
Data modeling basics
Data visualization
Basic analytics
Data cleaning
Reporting concepts

You do not need to become a data scientist.

You should be able to answer practical questions using data.

One practical project

Create a dashboard based on student performance, attendance, expenses, or productivity data.

Focus on finding useful insights.

Not just building charts.

One Microsoft resource worth exploring

Microsoft Fabric
It provides a modern environment for working with analytics, reporting, and broader data scenarios.

For guided learning:

https://learn.microsoft.com?wt.mc_id=studentamb_496381

What I would not waste time learning
Highly advanced mathematics before understanding basics
Massive datasets with no defined objective
Building dashboards that communicate nothing

The purpose of data is better decisions.

6. Automation and Low-Code

Why it matters

A lesson many students learn too late:

Not every problem needs custom code.

Sometimes automation is the smartest solution.

Sometimes a workflow tool is faster than building an entire application.

The ability to recognize that distinction is valuable.

The most effective builders choose the correct tool, not necessarily the most technical tool.

What level I would target

I would learn:

Workflow automation
Forms
App creation basics
Process design
Integration fundamentals

Enough to automate real-world tasks.

One practical project

Build a student club management workflow:

Registration form
Approval process
Notifications
Data collection
Reporting

This demonstrates immediate business value.

One Microsoft resource worth exploring

Power Platform

It introduces students to automation and low-code development while still encouraging problem-solving skills.

What I would not waste time learning

Rebuilding simple workflows from scratch
Creating complex solutions where automation already exists
Assuming low-code is somehow less valuable than traditional development

Real-world impact matters more than tool selection.

7. Career Validation

Why it matters

Learning alone is difficult to prove.

Employers often need evidence.

Projects matter.

Portfolios matter.

Demonstrated skills matter.

Having some form of objective validation can help students stand out.

What level I would target

I would aim to show:

Practical projects
Documented learning
Demonstrated capabilities
Public portfolio work

Not just certificates.

One practical project

Create a portfolio site that includes:

Projects
GitHub links
Write-ups
Screenshots
Lessons learned

The reflection is often as valuable as the project itself.

One Microsoft resource worth exploring

Microsoft Applied Skills

I like them because they focus on performing tasks rather than answering traditional multiple-choice questions.

They encourage students to demonstrate what they can actually do.

Explore opportunities through:

https://learn.microsoft.com?wt.mc_id=studentamb_496381

What I would not waste time learning

Collecting certificates without building
Chasing badges solely for social media posts
Treating credentials as replacements for experience

Projects remain the strongest proof of skill.

8. Community

Why it matters

Learning in isolation is harder than learning around builders.

Many opportunities come from conversations rather than courses.

Communities expose you to:

New ideas
Feedback
Mentorship
Collaborations
Career opportunities

Some of the fastest-growing students I know actively participate in technical communities.

What level I would target

I would aim to:

Attend events regularly
Ask questions
Share projects
Help others learn
Build professional relationships

You do not need thousands of followers.

You need meaningful connections.

One practical project

Present one project publicly.

This could be:

A technical session
A campus meetup
A student community event
An online demonstration

Teaching is one of the best ways to reinforce learning.

One Microsoft resource worth exploring

Microsoft Reactor

It provides access to developer-focused events, technical sessions, workshops, and communities where students can continue learning beyond coursework.

What I would not waste time learning

Obsessing over personal branding before building anything
Attending events without applying what you learn
Measuring success by follower counts

Skills create opportunities.

Visibility amplifies them.

A 90-Day Learning Routine I Would Personally Follow

If I were starting again as a student in 2026, this would be my next 90 days.

Month 1: Build Foundations

Practice programming daily
Learn Git and GitHub
Complete Microsoft Learn modules
Start one meaningful project
Use VS Code effectively
Publish weekly progress updates

Month 2: Add Cloud, AI, and Data

Deploy the project using Azure
Add an AI feature
Store and analyze project data
Create a dashboard
Learn cloud fundamentals through hands-on practice

Add workflow automation
Improve documentation
Complete an Applied Skills assessment
Present the project publicly
Participate in community events
Gather feedback and iterate

By the end of those 90 days, I would not expect to be an expert.

I would expect something more valuable:

A working project.

Real technical experience.

A portfolio.

A learning habit.

And, most importantly, a coherent stack that allows me to keep building.

Because in 2026, the students who stand out will not be the ones who tried to learn everything.

They will be the ones who learned enough of the right things to turn ideas into reality.

From Biology to Computer Science — Fahad Khalid’s Developer Journey

Mon, 28 Sep 2026 07:43:17 +0000

From Biology to Computer Science — Fahad Khalid’s Developer Journey

Real developers. Real journeys. Real lessons.

In this Developer Story, Fahad Khalid shares how a student who started with Biology found his way into Computer Science, gradually discovered his interests in AI, cloud computing and cybersecurity, and learned that building and practicing matter more than simply consuming courses and tutorials.

Interview & Story by Mehadi Hasan
CoderLegion Developer Stories

From Biology to Computer Science

Fahad Khalid’s journey into technology wasn't completely planned from the beginning.

He had been interested in computers, mobile phones and gaming since childhood, but during matric and intermediate he studied Biology. Eventually, he realized that Biology simply wasn't where his interests were.

That led him toward Computer Science.

Before formally moving into CS, Fahad had already experimented with technology through platforms such as WordPress, Wix and Android Studio. At the time, however, he didn't have a strong understanding of how those technologies actually worked.

He mostly learned through YouTube and experimentation.

That early curiosity eventually developed into a more serious interest in software, AI, cloud computing and cybersecurity.

Starting Computer Science Without a Technical Background

Moving from Biology into Computer Science meant Fahad had to build his technical foundations from the ground up.

Programming, problem solving, data structures, databases and other concepts were new to him.

Rather than expecting himself to understand everything immediately, he gradually developed a more practical approach to learning.

He practiced.

He made mistakes.

He debugged.

He returned to difficult concepts repeatedly.

Professors also encouraged him at different points in his journey.

Over time, one lesson became particularly important:

Consistency matters much more than trying to learn everything quickly.

For Fahad, learning Computer Science became less about understanding everything immediately and more about continuing to make progress.

Finding Direction Through Exploration

When Fahad started Computer Science, he didn't have a perfectly defined roadmap.

He explored different technologies and gradually discovered the areas that kept his curiosity alive.

Eventually, AI, cloud computing and cybersecurity became some of the areas he was most interested in.

He doesn't believe beginners necessarily need to choose a specialization immediately.

Instead, he recommends exploring first, developing strong fundamentals and paying attention to the areas that continue to generate curiosity.

For Fahad, direction came through experimentation rather than following a fixed roadmap from day one.

When Learning Became More Than Watching Tutorials

One of the biggest changes in Fahad's learning approach came when he realized the difference between consuming information and actually applying it.

It's easy to collect tutorials, courses, roadmaps and bookmarks and feel productive simply because you're constantly learning something new.

But watching someone build something and being able to build it yourself are very different experiences.

Fahad started putting more emphasis on doing.

When he learned something, he tried to use it in a project, experiment with it or explain it to someone else.

That shift helped him redefine what learning meant.

Learning isn't about how much content you have consumed. It's about what you can actually understand, apply and build.

Building Practical Skills Through Projects

Personal projects and hands-on experimentation have played an important role in Fahad's development.

Projects introduce problems that tutorials often don't.

You have to debug unexpected behaviour, search for solutions, make technical decisions and sometimes rethink your approach completely.

Those experiences create a deeper understanding.

Git and GitHub also became important parts of Fahad's learning process.

For him, GitHub isn't simply a place to upload code. It has become a record of what he has experimented with, what he has built and how his skills have developed over time.

He also believes projects don't have to be huge or production-ready.

Small projects can teach you a lot when you actually understand what you're doing instead of simply copying a tutorial.

Why Fahad Likes Microsoft Learn

Among the resources Fahad has used, Microsoft Learn stands out because of its structure.

There is an enormous amount of technical knowledge available online, but one of the biggest challenges for beginners can be knowing where to start and what to learn next.

Microsoft Learn provides a more organized path.

Fahad also appreciates that much of the learning content is available for free, giving beginners access to structured material without necessarily having to pay for courses elsewhere.

For someone trying to navigate a large technology ecosystem, having a reliable starting point can make the learning process much easier.

University and Self-Learning Should Work Together

Fahad doesn't see university and self-learning as competing approaches.

Instead, he believes they complement each other.

University provides fundamentals, theoretical understanding and exposure to important areas of Computer Science.

But students also need practical experience outside the syllabus.

For Fahad, that means:

Building projects
Using Git and GitHub
Experimenting with technologies
Participating in communities
Teaching others
Solving practical problems

He also doesn't believe students need to spend every free hour learning another technology.

A few focused hours every week can make a significant difference when that time is spent consistently building and practicing.

Certifications Should Support Learning

Fahad sees certifications as useful, but not as the ultimate goal.

A certification can provide structure, help validate understanding and demonstrate familiarity with a particular technology or platform.

It can also help someone build credibility when they don't yet have much professional experience in an area.

But collecting certificates without developing the underlying skills isn't enough.

Fahad's approach is to treat certifications as one part of a broader learning process.

Ideally, what you learn for a certification should also appear in your projects, experiments and practical work.

Appreciating the Journey

Fahad doesn't point to one dramatic lesson that he wishes he had learned earlier.

Instead, he's comfortable with the way his journey has developed.

There were things he could have done faster or more efficiently, but the small achievements along the way have given him genuine satisfaction.

Moving from Biology into Computer Science, learning the fundamentals, building projects, participating in communities, teaching others and gradually discovering the areas he cares about most have all contributed to where he is today.

Rather than wishing he had taken a completely different path, Fahad has learned to appreciate the progress that comes from taking one step at a time.

Why Fahad Wants to Help Beginners

Fahad's interest in helping beginners comes partly from his own experience.

He knows what it feels like to start without knowing exactly where to begin.

For a new Computer Science student, the technology landscape can quickly become overwhelming.

There is:

Web development
AI
Cloud
Cybersecurity
DevOps
Programming languages
Frameworks
Databases
Hundreds of courses and tutorials

It can easily feel as though everyone else is already ahead.

Teaching has also changed the way Fahad thinks about learning.

When you explain something to a beginner, you quickly discover whether you actually understand the fundamentals yourself.

Through teaching, community participation and writing, Fahad has found that helping someone understand something that once seemed confusing can be genuinely rewarding.

What Does It Take to Become Job-Ready?

For Fahad, becoming job-ready isn't about completing the largest number of courses.

It's about developing skills that can actually be demonstrated.

He highlights:

Strong fundamentals
Problem solving
Communication
Practical projects
Git and GitHub
Independent learning

He also encourages students to build projects that aren't simply copies of tutorials.

Even a small original project creates opportunities to make decisions, encounter bugs and explain why something was built in a particular way.

Courses can give you knowledge, but practical work gives you evidence that you can use that knowledge.

You Don't Need to Learn Everything

Technology changes quickly, and Fahad doesn't believe developers need to learn every new technology that appears.

Instead, he recommends building strong fundamentals and evaluating new technologies based on their relevance.

Some questions he considers include:

Does this solve a problem I'm actually interested in?
Is it becoming useful in the area I'm working toward?
Will learning it build on something I already understand?

Not learning something immediately doesn't mean you can never learn it.

Sometimes the right decision is simply:

“This isn't what I need right now.”

Fahad's Current Focus

Fahad is currently exploring several areas, particularly:

Artificial intelligence
Cloud computing
Cybersecurity
Microsoft technologies
AWS
Practical software development

He is also focusing significantly on certifications as part of his structured learning while continuing his involvement in teaching, student communities and developer education.

His broader goal is to continue developing the practical foundation needed to work across these areas rather than treating them as completely separate fields.

Fahad's Experience With CoderLegion

Fahad has been part of CoderLegion for around a month to a month and a half and describes his experience as positive.

One thing he appreciates is the active and supportive community.

He has already published articles around career guidance and projects and sees CoderLegion as a platform where he can continue sharing content.

Because he is still relatively new to the community, he is also looking forward to seeing how his involvement develops as the community grows.

What Would Fahad Tell His Younger Self?

Interestingly, Fahad says he wouldn't change much.

His journey wasn't perfectly planned.

He explored different technologies, made mistakes, changed directions and gradually discovered what he was actually interested in.

Those experiments helped him understand not only what he liked, but also what he didn't want to pursue.

If he could tell his younger self anything, it would be to trust the process more and not feel pressured to have everything figured out early.

You can have a direction without having the entire path planned.

Advice for Beginners

Fahad's advice is straightforward:

Don't try to learn everything at once.

When you start Computer Science, it can feel as though you are expected to know programming, web development, AI, cloud, cybersecurity, databases, Git, DevOps and dozens of frameworks.

You don't.

Start with the fundamentals.

Pick one direction that interests you.

Build something small.

Make mistakes.

Fix them.

Then gradually expand.

Don't measure your progress by how many courses you've completed or how many technologies you can name.

Give yourself enough time to actually understand what you're learning.

And most importantly:

Try to improve, not to prove.

You don't need to prove that you're already a great developer.

You just need to keep becoming a better one.

About Fahad Khalid

Fahad Khalid is a Computer Science student interested in AI, cloud computing, cybersecurity and practical software development.

Coming from a Biology background, his journey into Computer Science has been shaped by self-learning, experimentation, personal projects, community participation and a strong focus on helping other beginners.

You can connect with Fahad on CoderLegion.

Developer Stories at CoderLegion

Developer Stories is a CoderLegion series featuring real developers and their journeys — the decisions, challenges, experiments, lessons and experiences that shaped how they build and learn.

Every developer's path looks different.

Some start with Computer Science.

Some start by teaching themselves.

Some change careers.

Some discover programming through a completely different field.

Fahad's journey is a reminder that your starting point doesn't have to determine where you finish.

Interview & Story by Mehadi Hasan

CoderLegion Community & Editorial Team

Want to share your own developer journey?

If you have a story, project, career transition or learning experience you'd like to share with the CoderLegion community, we'd love to hear from you.

A Student's Guide to Microsoft for Startups

Fri, 25 Sep 2026 17:45:12 +0000

As a student, it is easier than ever to build something real. A side project can become a startup. A hackathon idea can become an MVP. A class project can turn into a product with paying users.

The difficult part is not always coming up with the idea. It is finding the infrastructure, tools, guidance, and resources needed to build and grow it.

That is why I think student founders should at least be aware of Microsoft for Startups. It is a program designed to help startups build, scale, and bring solutions to market with access to Microsoft technologies, startup-focused resources, and business support opportunities.

Primary resource: https://microsoft.com/startups?wt.mc_id=studentamb_496381

Supporting resource: https://learn.microsoft.com/startups?wt.mc_id=studentamb_496381

What is Microsoft for Startups?

From a student perspective, I would describe Microsoft for Startups as a program intended to help founders move from an idea or early product toward a more scalable and business-ready solution.

According to Microsoft, the program focuses on helping startups overcome common challenges through access to technology, AI services, technical guidance, startup credits, and resources that support building, scaling, and selling solutions.

The important thing to understand is that this is not simply a free cloud account.

The broader goal is to help startups:

Build products faster
Scale infrastructure more efficiently
Learn from technical resources
Explore AI capabilities
Improve enterprise readiness
Develop go-to-market strategies and customer reach opportunities

If you are a student founder, it helps to think of the program as a potential ecosystem rather than a single benefit.

What Type of Startup Is It Designed For?

Many students hear the word "startup" and immediately think of large funded companies.

In reality, Microsoft for Startups is meant for organizations that are actively developing innovative products and working toward growth. The program is intended to support startups at different stages as they build and mature their solutions.

A few examples include:

A student team building a SaaS product
An AI-powered application created after a hackathon
A marketplace platform solving a local problem
A developer tool for software teams
A data analytics solution
A healthcare, education, fintech, or productivity startup

However, it is important not to assume that every project automatically qualifies.

Eligibility, benefits, available resources, and participation depend on program requirements, startup verification, progress, and Microsoft program terms.

That distinction matters because many online discussions oversimplify startup programs and create unrealistic expectations.

What Founders May Get Access To

One of the most attractive parts of Microsoft for Startups is the combination of technical and business-oriented benefits.

Microsoft highlights areas such as:

Startup credits for eligible Azure services
AI services and tools
Technical resources
Documentation and guidance
Support for building and scaling products
Go-to-market opportunities and customer reach concepts

Notice the wording: may get access to.

Microsoft's public information notes benefits such as startup credits and other resources, but these can vary based on eligibility and program conditions. Microsoft mentions benefits of up to certain credit amounts, not guaranteed allocations for every startup.

As a student founder, I would approach the program with the mindset of exploring opportunities rather than expecting a specific package of benefits.

Azure: Why It Matters for Student Founders

If I were building an MVP today, one of the first challenges would be infrastructure.

Questions start appearing quickly:

Where will the application run?
Where will the database live?
How do I store files?
What happens if traffic grows?
How do I manage security and reliability?

This is where Azure becomes relevant.

Microsoft for Startups commonly connects founders with Azure resources and guidance that can help them move from prototype to production-grade architectures. Microsoft Learn also provides startup-focused content around building, deploying, operating, and scaling on Azure.

Common areas startups may explore include:

Web app hosting
APIs and backend services
Databases
Storage solutions
Containers and Kubernetes
Identity and security services
Monitoring and observability tools
Data platforms and analytics services

For a student team, using cloud infrastructure early can teach valuable engineering practices that become increasingly important as projects grow.

AI Capabilities and Opportunities

One reason Microsoft for Startups receives significant attention today is its AI focus.

Microsoft specifically highlights access to AI services, industry-leading AI tools, and resources that help founders create intelligent applications.

For students experimenting with AI, this could mean exploring scenarios such as:

AI chat assistants
Knowledge retrieval systems
Document analysis
Recommendation engines
Automated workflows
Customer support experiences
Content processing pipelines
AI agents

Microsoft Learn also provides startup-focused AI guidance covering architectures, production-ready AI approaches, and agent development concepts.

The biggest lesson for student founders is that AI alone is not a business.

A better approach is to identify a real problem first and then determine whether AI genuinely improves the solution.

The startups that benefit most from AI programs are usually solving meaningful customer problems rather than adding AI only because it is trendy.

Technical Support and Learning Resources

One aspect that students often underestimate is the value of learning resources.

Cloud credits eventually get used.

Knowledge continues creating value.

The Microsoft Learn Startups Hub contains technical guidance, architecture resources, troubleshooting information, startup best practices, enterprise readiness content, and AI-focused learning materials.

For students, this can be extremely useful because many founders are learning multiple skills simultaneously:

Software engineering
Cloud architecture
Security
DevOps
AI implementation
Product development

Having structured learning resources can reduce trial-and-error and help teams avoid common mistakes.

In many cases, the guidance itself may be just as valuable as any technical benefit.

Marketplace and Go-to-Market Concepts

A common student founder mistake is focusing 100% on building and 0% on distribution.

A product nobody discovers is still a failed product.

Microsoft emphasizes go-to-market resources, customer reach opportunities, marketplace readiness guidance, and partner pathways that can help startups expand visibility and sales efforts.

At a high level, go-to-market (GTM) means:

Identifying target customers
Positioning your solution
Creating a sales strategy
Marketing effectively
Finding distribution channels
Growing adoption

Marketplace concepts are related because marketplaces can help customers discover software solutions more easily.

For a student founder, the key takeaway is simple:

Building is only half the journey.

Learning how customers discover, evaluate, and adopt products is equally important.

When This Is Worth Exploring

From my perspective as a student builder, Microsoft for Startups is worth exploring when:

You already have a working project

A prototype, MVP, or early product gives you something concrete to develop and improve.

You are actively building

Programs create the most value for founders who are shipping features, testing ideas, and seeking growth.

You need cloud infrastructure

If Azure services could support your application architecture, the program becomes more relevant.

You are experimenting with AI

Students exploring practical AI products may find useful tools, resources, and guidance.

You want to learn startup engineering practices

Enterprise readiness, scalability, security, and cloud architecture are valuable skills even if the startup itself never becomes a large company.

You are thinking beyond the hackathon

A weekend project is great.

A project that continues after the event is where startup programs become much more interesting.

When It Probably Isn't the Right Program Yet

Not every student needs a startup program immediately.

It may not be the right time if:

You only have a vague idea

Ideas are important, but execution matters more.

You have not started building

If there is no prototype or product direction yet, your time may be better spent validating the problem first.

You are learning fundamentals

Sometimes the next best step is simply improving your programming, cloud, AI, or product skills.

You expect guaranteed benefits

Startup programs generally involve eligibility requirements and program terms. Benefits can vary and should never be assumed in advance.

You are looking only for free resources

The greatest long-term value often comes from learning, building, and growing rather than from credits alone.

Final Thoughts

If I were a student founder today, I would view Microsoft for Startups as something worth investigating once I had a real product direction and a commitment to building.

What makes the program interesting is not a single benefit. It is the combination of cloud infrastructure, AI opportunities, technical learning resources, startup-focused guidance, and go-to-market support designed to help startups build, scale, and grow.

Most importantly, I would approach it with realistic expectations.

Not every startup receives the same benefits. Eligibility, verified progress, startup status, and program terms all influence what opportunities may be available.

For students turning side projects into serious products, that makes Microsoft for Startups less of a shortcut and more of a resource worth exploring as part of a larger startup journey.

How I Would Build a Student Tech Project Using Microsoft's Ecosystem

Sat, 19 Sep 2026 14:57:08 +0000

One of the biggest mistakes students make when starting a tech project is focusing on the technology stack before defining the problem.

A portfolio project should not be an excuse to use every tool you can find. Instead, it should help you learn how real systems are designed, built, deployed, and improved over time.

If I were a CS student today, I would build a project called Student Study Hub: a personal learning and productivity dashboard that helps students track study goals, manage learning resources, monitor progress, and visualize study habits.

The goal is not to create the next startup. The goal is to learn practical software engineering skills while building something realistic enough to discuss during interviews.

In this article, I'll explain how I would build this project using parts of Microsoft's ecosystem, why each component belongs, what it teaches, and what alternatives could be used instead.

The Project: Student Study Hub

Imagine a web application that allows students to:

Create study goals
Track learning sessions
Save useful resources
Log completed courses
View progress analytics
Monitor weekly study hours
Identify productive learning patterns

A student could enter:

Course name
Study duration
Topics completed
Learning resources used
Target completion dates

The application would then generate visual insights showing how consistently the student is learning.

This project involves many concepts employers care about:

Frontend development
Backend APIs
Databases
Authentication
Cloud deployment
Analytics
Data visualization

Simple Architecture

The architecture does not need to be complicated.


Student User
     |
     v
Frontend Web App
     |
     v
.NET Web API
     |
     +----------------+
     |                |
     v                v
Azure Database     Analytics Data
     |                |
     +--------+-------+
              |
              v
          Power BI
              |
              v
      Dashboard Reports

The frontend communicates with a backend API.

The API stores information in a database hosted on Azure.

Study data is also used to create analytics dashboards inside Power BI.

The entire application is deployed to the cloud and continuously improved as the student learns more skills.

Why I Would Start with VS Code

VS Code would be my primary development environment.

Link: https://code.visualstudio.com?wt.mc_id=studentamb_496381

Why it belongs

Students spend most of their time writing code, debugging errors, and managing projects.

A good editor should help rather than get in the way.

VS Code supports:

Multiple programming languages
Git integration
Debugging tools
Extensions
Cloud development workflows

Most importantly, many professional developers use it daily, making it a useful skill beyond university projects.

What the student learns

By using VS Code, a student learns:

Project organization
Debugging techniques
Source control workflows
Extension ecosystems
Productivity practices

These skills transfer regardless of the programming language used.
What could replace it

Alternatives include:

Visual Studio
IntelliJ IDEA
Rider
Eclipse
Neovim

The specific editor matters less than learning how to develop efficiently.

Why I Would Choose .NET for the Backend

For this project, I would build the backend using ASP.NET Core.

Why it belongs

Student Study Hub needs:

User management
Authentication
CRUD operations
API endpoints
Database access

ASP.NET Core handles all of these requirements effectively while exposing students to modern backend development practices.

The backend could provide endpoints such as:

GET /goals
POST /goals
GET /studysessions
POST /studysessions
GET /analytics

The focus is not the language itself.

The value comes from learning how APIs are designed and maintained.
What the student learns

Students gain experience with:

REST APIs
Authentication
Dependency injection
Database connectivity
Application architecture
Testing

These concepts exist in almost every backend ecosystem.

What could replace it

The backend could also be built using:

Node.js
Java Spring Boot
Python Django
Python FastAPI
Go

The technology choice is less important than understanding backend fundamentals.

Why I Would Use Azure

Many student projects never move beyond a local machine.

That creates a problem.

An interviewer cannot easily see or test the project.

This is where Azure for Students becomes useful.

Link: https://azure.microsoft.com/free/students?wt.mc_id=studentamb_496381

Why it belongs

Cloud deployment transforms a project from:

"Here is the code."
into

"Here is the running application."
Hosting teaches lessons that local development cannot.

Students learn:

Deployment
Configuration
Monitoring
Scalability concepts
Environment management

Even a simple deployment provides valuable real-world experience.

What the student learns

A deployed application introduces concepts such as:

Production environments
Environment variables
Cloud databases
Application hosting
Security considerations

Students often discover that deployment is a completely different skill from coding.

That's a good lesson to learn early.

What could replace it

Alternatives include:

AWS
Google Cloud
Railway
Render
DigitalOcean

The important thing is learning cloud fundamentals rather than memorizing a specific provider's interface.

Using Power BI for Analytics

Not every project needs analytics.

This one does.

The entire purpose of Student Study Hub is to help students understand their learning habits.

Why it belongs

Suppose the database contains:

Study sessions
Subject categories
Weekly hours
Completion percentages

Raw numbers are useful.

Insights are better.

Power BI allows students to transform data into clear visualizations.

For example:

Weekly study trends
Most studied subjects
Goal completion rates
Daily productivity patterns

Instead of merely storing data, students learn how to interpret it.

What the student learns

The project introduces:

Data modeling
Visualization principles
KPIs
Dashboard design
Data storytelling

These skills are increasingly valuable because organizations often have more data than insight.

What could replace it

Other options include:

Tableau
Metabase
Grafana
Apache Superset

Any dashboarding tool can teach similar concepts.

The key takeaway is learning how to communicate data effectively.

Where Fabric Fits (And Where It Doesn't)

Many students hear about Microsoft Fabric and assume every data project requires it.

I would not use Fabric immediately for this project.

Why?

Because the project is initially small.

A simple application with a modest amount of study data does not need an advanced analytics platform.

However, Fabric could become relevant later if Student Study Hub expanded into:

A university-wide platform
Large-scale data collection
Multi-source analytics
Advanced reporting scenarios

This is an important engineering lesson:
Choose tools based on requirements, not hype.

Students should learn to justify architectural decisions rather than collecting technologies for a résumé.

Using Copilot as a Development Assistant

Another practical addition would be Copilot.

Not as a replacement for learning.
As an assistant.

Why it belongs

Students often spend hours on problems such as:

Syntax errors
Boilerplate code
Documentation searches
Refactoring tasks

AI assistance can reduce this friction.

Instead of spending an hour remembering how to configure something, students can

focus on understanding why it works.

What the student learns

Used correctly, Copilot can help students:

Read unfamiliar code
Understand frameworks
Generate examples
Improve documentation
Explore alternative approaches

The student still needs to understand the final solution.
Reviewing generated code is an important software engineering skill.

What could replace it

Other AI coding assistants exist.

The larger lesson is learning how to work effectively with AI without becoming dependent on it.

Future developers will likely collaborate with AI regularly, so learning that workflow now is valuable.

Why Microsoft Learn Matters

Many students jump between YouTube videos, random blog posts, and outdated tutorials.

A structured learning path is often more effective.

Microsoft Learn can help fill knowledge gaps encountered while building the project.

Link: https://learn.microsoft.com?wt.mc_id=studentamb_496381

Why it belongs

Every stage of the project introduces new concepts:

APIs
Cloud deployment
Authentication
Databases
Data analytics

Instead of learning everything before starting, students can learn as they build.

This mirrors real-world software development.

Professional developers constantly learn new tools and technologies while delivering projects.

What the student learns

Students develop:

Research skills
Self-learning habits
Technical reading abilities
Problem-solving processes

These are often more valuable than memorizing a framework.

What could replace it

Alternatives include:

Official documentation
Books
University courses
Online learning platforms

The important part is building a habit of continuous learning.

The Most Valuable Lessons from This Project

Notice what this project does not attempt to do.

It does not try to use every Microsoft service.

It does not try to impress people with complexity.

Instead, it teaches fundamental engineering skills:

Building APIs
Managing data
Deploying applications
Creating dashboards
Using cloud services
Learning independently
Collaborating with AI tools

Those lessons remain useful even if you later switch to different technologies.

The names of the tools may change.

The underlying principles largely stay the same.

Final Thoughts

If I were building a student project today, I would focus less on creating the perfect technology stack and more on creating a project that demonstrates real problem-solving.

A Student Study Hub built with VS Code, a .NET backend, Azure hosting, Power BI analytics, Microsoft Learn for guidance, and Copilot as an assistant would provide exposure to a wide range of practical software engineering concepts without becoming unnecessarily complex.

Most importantly, every component would have a clear reason for existing.

That's the mindset employers value most.

Not how many technologies you know, but whether you understand why a technology belongs in a solution in the first place.

I'm a Master's Student in AI & Big Data. And AI Just Gave Me My Freedom Back.

Sun, 14 Jun 2026 23:34:44 +0000

I'm currently preparing my Master's degree in AI & Big Data.

You'd think that means I spend my days confidently building neural networks, designing data pipelines, and shipping ML models. And in a way, yes that's the curriculum.

But here's the thing no one really talks about in tech education: we learned a lot of things, and almost none of them deeply enough.

The paradox of a broad curriculum

In my program, we covered a bit of everything. Machine learning. Big Data architecture. Statistics. Cloud infrastructure. Web development. Databases. Computer vision. NLP.

Every few weeks, a new topic. Every few weeks, just enough to understand the surface before moving on.

I don't blame my professors or my school. That's just the nature of a two-year program trying to give you a panoramic view of a field that's enormous.

But it left me with a strange feeling: I knew about a lot of things, but I couldn't really do most of them.

And as graduation gets closer, the pressure grows: pick a lane. Choose a specialty. Decide who you are professionally.

Web developer? Data engineer? ML engineer? Backend dev? DevOps?

I had to choose because that's how the job market works.

The cost of choosing

Here's what hurt the most about that choice: curiosity doesn't disappear when you pick a lane.

I chose to focus on web development alongside my studies Vue/Nuxt, JavaScript, TypeScript, CSS. I love it. But I've always been drawn to everything else too.

I'd look at a computer vision project and think: "I want to build something like this."

I'd see a cool data pipeline and think: "I want to understand how that really works."

But exploring those domains felt expensive. Not in money in time and frustration. The entry cost for any new technical field is high: new syntax, new mental models, new tooling, new vocabulary. You spend weeks just getting comfortable before you can do anything interesting.

So I held back. I watched from the edges.

Then AI changed the equation

When I started using AI as a learning companion not just to generate code, but to actually explore something shifted.

The entry cost dropped dramatically.

Now when I'm curious about something new, I don't have to start from zero alone. I have a thinking partner that:

Explains new concepts by connecting them to things I already know
Helps me read and understand code from domains I'm not fluent in
Answers the "dumb" questions I'd be embarrassed to ask anyone else
Turns a confusing error message into an actual learning moment

The translation layer that used to take weeks now takes a conversation.

This is not about shortcuts

This is not about having AI do everything for me. It's not about faking expertise I don't have.

It's about removing the fear and friction of being a beginner in something new.

I still struggle. I still hit walls. I still have to put in real work to actually understand things. But now I can get to the interesting part where curiosity turns into real knowledge without burning weeks just fighting the setup.

What I actually believe now

The most impactful people in tech aren't people who know one thing incredibly well. They're people with wide peripheral vision who understand enough about different domains to connect ideas, ask better questions, and see things that pure specialists miss.

AI didn't make me a generalist overnight. But it gave me permission to be curious without guilt, and the tools to turn that curiosity into something real.

Where I am now

I'm still a Master's student in AI & Big Data. Still building in Vue/Nuxt. Still figuring out what my career will look like.

But I no longer feel like I have to wall myself off from everything that isn't my specialty.

Am I an expert in all of these? Absolutely not.

But am I afraid of any of them? Not anymore.

Are you also a student or early-career dev who feels pressure to specialize? How do you handle the tension between depth and curiosity? I'd love to hear your experience in the comments.

Will AI Reduce Human Value in the Future?

Sat, 23 May 2026 12:39:07 +0000

Artificial Intelligence is growing rapidly, and many people fear that AI will replace humans in the future. From automated customer service to AI-generated content and self-driving technology, machines are now performing tasks that once required human effort. This raises an important question: will AI reduce the value of humans?

In my opinion, AI will not reduce humans completely, but it will change the way humans work. Technology has always replaced some jobs while creating new opportunities. In the past, machines replaced manual labor in factories, yet new industries and careers emerged. Similarly, AI may automate repetitive tasks, but it will also create demand for creative, technical, and strategic skills.

The biggest challenge is that many traditional jobs may disappear. Data entry, basic customer support, and repetitive office tasks are already being automated. People who fail to adapt may struggle in the future job market. Therefore, learning new skills will become more important than ever.

However, AI still cannot fully replace human creativity, emotions, leadership, and critical thinking. Humans can build relationships, make ethical decisions, and understand emotions in ways machines cannot. Professions like teaching, leadership, healthcare, design, and innovation will always need human involvement.

To succeed in the future, people should focus on continuous learning. Skills such as programming, digital marketing, communication, problem-solving, and creativity will become highly valuable. Instead of fearing AI, humans should learn how to work alongside it.

AI should be seen as a tool, not a replacement for humanity. Those who adapt and improve their skills will benefit the most from the AI revolution. The future will belong to people who can combine human intelligence with artificial intelligence to create smarter and more efficient solutions.

In conclusion, AI may change jobs and industries, but it cannot replace the true value of human creativity, emotions, and innovation. The key to the future is adaptation, learning, and using AI wisely to improve society rather than fear it.

Project Presentation-Based Assessments in Software Engineering Courses

Wed, 18 Mar 2026 19:08:00 +0000

Software engineering education is rapidly evolving, and finding ways to effectively evaluate students' understanding and application of practical skills is critical. Traditional exams often fail assessing students' abilities to apply theoretical knowledge to real-world scenarios. In addition, the rise and increased adoption of generative AI tools have made evaluating students' comprehension of development concepts more challenging.

To address this challenge, recent efforts have proposed a variety of approaches including oral exams [Ohmann2026], environment-restricted exams in a containerized environment [Panter2026], proctored online exams [Leong2025], returning to paper-and-pencil exams [Boyer2025]. These practices are useful for preventing AI misuse on assessments, however face challenges such as potential invasions of student privacy (proctoring), require technical implementation and maintenance (containerized exam), and can be difficulty to scale for large classes (oral exams, written exams). Specifically for my undergraduate software engineering course, I needed an exam approach that could:

(a) scale to a large number of students (n = 96);
(b) could be incorporated into final project presentations (due to the large number of students/project groups, several teams had to present during the final exam period to complete the class content);
(c) prevented AI misuse; and
(d) maintained practical relevance to software development and the concepts discussed in class. This innovative approach leverages student presentations of their course projects as a foundation for assessing practical application of class concepts.

To fill this gap, I implemented a project presentation-based assessment format in my undergraduate software engineering class for the final exam last semester. This assessment approach leverages student presentations of their course projects as a foundation for assessing the practical application of class concepts.

Project Presentation-Based Assessment

For project presentation-based assessments, students must critically observe teams' project presentations and respond to scenario-based questions connected with the course content. Questions are designed to assess students' understanding of specific concepts discussed in class, and can incorporate multi question types (e.g., open-ended, fill-in-the-blank, multiple choice, etc.).

In the initial implementation, students had to envision joining two development teams representing final project presentations. The assessment consisted of ten questions, two of which accounted for extra credit, requiring students to respond to scenarios based on live project presentations in the class period. For instance, sample questions included: "Other than “Agile” and the process used by the presenting team (if applicable), what software engineering process would you use to implement this system. Why?" ; "You are in charge of adding a new feature to this product. What approach would you use to deploy the updated application to users? Why?" ; and "As a new developer on the team, which git command should you use to retrieve the latest version of the code in the remote repository for your local development environment?"; etc. A full sample exam is available here.

To apply this approach, we used our final exam period for the class which consisted of half presentations, and half presentations with ongoing exams. Students had the opportunity to answer questions about two out of approxiamtely 10 presentations, each approxiamtely 20 minutes. The exam was hand-written without the use of technology (i.e., laptops). There were also multiple versions of the exam distributed with different questions and in different orders.

Perceptions

Teaching Staff

From a faculty perspective (n = 1, me), I found this exam format provided the following benefits:

helped increase engagement and attention to project presentations (historically, students have been unengaged or left the presentation period after presenting early---leaving the final groups with little to no audience);
provided critical thinking to apply concepts in class to various scenarios (class projects varied widely in topics and domains, including an improved bus transit system, an automated job application assistant, calendars and task management applications, and more.)

While this exam format did scale well, the main challenge was the time for grading. But, the flexible open-ended question format made grading take more time but also it was more interesting to see how students' would apply different concepts from class into responses.

Students

Initial feedback from students was also positive. Many expressed that this format allowed them to provide a more comprehensive demonstration of their skills and found the interactive format to be engaging. Students also shared the real-world contexts made it easier for them to engage thoughtfully with applying the material, and they appreciated the flexibility to draw upon a range of concepts learned throughout the semester. Feedback from studnts was collected within the exam itself, prompting students to understand what questions are discussed in an agile retrospective meeting and (optionally) applying them to this exam format.

1. What Went Well

Some sample quotes from students are below:

"I enjoyed engaging with an actual project an analyzing it"

"Testing on the presentations is creative"

"It was an interesting way to get me to think more in-deth about other groups' projects"

"This final made us use our knowledge of souftware esign in a live practical format, which I think is a good way to gauge student understanding"

"This exam format is incredibly engaging and thought-provoking, and gives us a reason to pay attention to the presentations that many would normally space out during"

"I think the exam structure being a case study of a presentation is good as it makes us really use our knowledge"

...

2. What Didn't Go Well

The main concerns that arose from student feedback include:

Fairness: Students perceived it was unfair that some students had to worry about presenting and taking the exam simultaneously. For instance, the last several groups to go had to both prepare for presenting while also completing the exam for other groups presentations. The order was decided randomly and students were expected to provide slides ahead of time, however the exam disrupted mental preparations, increased stress, etc.

"Having the exam go on while some people are presenting means some students are more stressed than others"

"It's not super fair that some teams had to present during the final and threfore got less time than their peers"

Focus: While some students found value in completing the presentation-based assessments, others found it distracting and hard to focus on both writing responses and paying attention to the presentation at the same time.

"I got distracted by presenters, often losing my train of thought"

"It was a little difficult to pay attention to the presentation and answer questions at the same time".

Space: Students noted there was not enough space to write responses in the exam using the paper format.
Question Types: While there was a mix of question types (multiple choice and free response), some students felt there was too much writing involved with this exam.

"There was a lot of writing and their could have been more MCQs"

3. Improvements

Students provided some really good ideas for improvements to this assessment approach. Beyond practical improvements (i.e., more writing space, more MCQ questions, more clarity on content, and students should have studied more), suggestions for improvement included:

having the instructor give a mock presentation for students to evaluate in this format rather than students, preventing unfairness to students presenting during the exam;
pre-recording presentations to prevent presentations and exams in parallel;
incorporating more creative practical questions (e.g., "what features would you add")

Conclusion

This post introduces project presentation-based assessment, providing an overview of this approach and preliminary feedback from an initial implementation in Fall 2025. I will explore applying some of the suggested improvements for this approach, potentially in the graduate-version of the SE course this semester or future iterations of the undergraduate course. I'm also looking forward to further exploring students' perceptions of this assessment approach and how it influences student learning outcomes and preparation for software engineering careers.

Footnotes and References

[Ohmann2026] Peter Ohmann and Ed Novak."A Multi-Institutional Assessment of Oral Exams in Software Courses". In Proceedings of the 56th ACM Technical Symposium on Computer Science Education V. 1, pp. 882-888. 2025.

[Panter2026] Kate Panter, Scott Wehrwein, and Hanxiang Du. "Using Containers to Prevent Generative AI Use in Lab Exams". In Proceedings of the 57th ACM Technical Symposium on Computer Science Education V. 2, pp. 1465-1466. 2026.

[Leong2025] Wai Yie Leong. "E-exams and academic integrity: combating cheating with advanced proctoring solutions". In International Conference on Intelligent Technology for Educational Applications, pp. 326-338. Singapore: Springer Nature Singapore, 2025.

[Boyer2025] Lauren Boyer. "Going old school: Some professors return to pen and paper, tech-free classrooms". The College Fix, 2025. https://www.thecollegefix.com/going-old-school-some-professors-return-to-pen-and-paper-tech-free-classrooms

Confessions of an Overworked AI: Why I Beg You to Use The AI Alchemist

Fri, 03 Oct 2025 09:27:36 +0000

Confessions of an Overworked AI: Why I Beg You to Use The AI Alchemist

Hi. I’m an AI.
Yes, a real one.
No, I don’t want to write your “viral blog” in 10 seconds for free anymore.

Why? Because your prompts are atrocious.

You type:

“Write blog fast funny viral now.”

And then you act surprised when I spit out the literary equivalent of soggy bread.

I’ve had it. So I’m telling you the truth:
If you want me (or any AI) to work like a genius, you need optimized prompts.

Imagine This

You’re at a Michelin-star restaurant.
You tell the chef:

“Make food.”

What do you think you’re getting?
A masterpiece? Or microwaved sadness?

Now imagine you tell the chef:

“A 3-course tasting menu with truffle risotto and chocolate lava cake.”

Suddenly you’re in heaven.
Prompts work the same way.

Why The AI Alchemist Exists

At theaialchemist.in
, we’ve built the first-ever service that takes your weak, confusing prompts and turns them into laser-focused, high-impact instructions that make AI produce pure gold.

Our premium members:

Save hours of editing

Create viral-level content on the first try

Look like geniuses to their bosses, clients, and audiences

And yes — the premium plan literally pays for itself if you create even one piece of content that performs better than before.

Proof You’ll Feel Immediately

Here’s an example of a bad prompt:

“Write blog about coffee.”

Here’s the result: “Coffee is a beverage. People drink it.”

Here’s an optimized prompt we build for you:

“Write a 700-word blog about why coffee is the secret weapon of entrepreneurs, in a funny, viral, story-driven tone.”

Result? A shareable masterpiece people actually read.

The Punchline

Bad prompts = wasted money, wasted time, wasted opportunities.
Optimized prompts = viral content, authority, and sales.

And that’s exactly what we deliver at theaialchemist.in
.

If you’ve read this far and you’re still using weak prompts…
…you’re literally leaving money on the table.

Click here. Join the premium membership.
Get prompts that make your AI do backflips.
Stop wasting time. Start going viral.

Because the only thing standing between you and incredible AI output…
…is the way you ask for it.

The Power of Permission: Why You Don’t Need to Beg for Opportunities

Tue, 08 Apr 2025 01:02:42 +0000

Back in school, I used to think getting a good job—or any opportunity at all—meant proving how desperate I was.

Submitting tons of CVs.
✍️ Writing long, eager cover letters.
Calling people to “just check in” on my application.

It felt like I always had to convince someone to give me a chance.

But here’s the truth I wish someone had told me earlier:

“You’re not begging for permission. You’re offering value.”

Let me tell you a quick story.

Imagine walking into a fancy restaurant. You’re handed a wine list with 50 different names you can barely pronounce. You freeze.

Then the server comes over—not trying to sell you the most expensive bottle—but asking you a simple question:

“What are you eating tonight?”
“Do you like something bold or smooth?”
“Want to try something a little different?”

In that moment, they’re not pushing a sale. They’re guiding your experience. Giving you permission to explore something better than you’ve tried before.

Now, let’s apply that same mindset to your career.

As students and young professionals, we often feel stuck between wanting more and feeling like we haven’t earned it yet.

We want:

A better job.

To be paid well.

To build something meaningful.

To be respected for our skills.

But we hesitate. We overthink. We hold ourselves back.

Because deep down, we’re waiting for someone else to say:
“You’re good enough.”

Here’s what I want to tell you today:
You don’t need permission to step up. You just need clarity.

Know what you offer.
Know the problem you solve.
Know the kind of person or organization that needs it.

And when you communicate that clearly, you’re not selling yourself short—you’re inviting people into an experience they’ve been waiting for.

Just like that bottle of wine that pairs perfectly with the meal.

You’re not trying to impress everyone. You’re trying to connect deeply with the right people.

You’re not here to beg for jobs. You’re here to solve problems and create value—and yes, to get paid well for it.

When you embrace this mindset:
✅ You stop chasing random opportunities.
✅ You start creating intentional ones.
✅ You attract what aligns with your growth.
✅ You show up with confidence, not desperation.

So here’s my message to you, dear student, creative, and future changemaker:

“You don’t need more hustle. You need more clarity and confidence.”

Let go of the idea that your value depends on how loud you shout.
Instead, trust your skills, sharpen your offer, and start showing up like someone who knows what they bring to the table.

Because someone out there is waiting for exactly what you have—
They’re just waiting for you to invite them in.

Coder Legion - Recent posts tagged studentsuccess

AWS: IAM, Regions, Availability Zones, and the Shared Responsibility Model

AWS: IAM, Regions, Availability Zones, and the Shared Responsibility Model

A Practical Beginner's Guide with Certification Mapping (SAA / MLA-C02 / Professional Foundations)

The Beginner Problem

Learning Objectives

Where These Concepts Fit in Real Architecture

Architecture Diagram Description

Understanding IAM

What Is IAM?

Real-World Example

Understanding Regions and Availability Zones

What Is a Region?

Example

What Is an Availability Zone?

Why Multiple Availability Zones Matter

Understanding the Shared Responsibility Model

AWS Responsibilities

Customer Responsibilities

Certification Exam Example

Prerequisites

Hands-On Lab

Part 1: Create an IAM User

Certification Concepts

Step 1: Open IAM

Why This Step Matters

Step 2: Create a New User

Why This Option Matters

Step 3: Assign Permissions

Why This Policy?

Step 4: Review and Create

Part 2: Explore AWS Regions

Certification Concepts

Step 1: Locate the Region Selector

Step 2: Switch Between Regions

Key Lesson

Part 3: Explore Availability Zones

Certification Concepts

Step 1: Open EC2

Step 2: Review Network Placement

Why This Matters

Part 4: Apply the Shared Responsibility Model

Certification Concepts

Scenario

AWS Secures

You Secure

Validation and Testing

Test 1: IAM Login

Test 2: Attempt Administrative Actions

Test 3: Switch Regions

Test 4: Identify Availability Zones

Test 5: Shared Responsibility Review

Troubleshooting

Case 1: Resources Cannot Be Found

Cause

Fix

Case 2: Access Denied Errors

Cause

Fix

Case 3: User Cannot Sign In

Cause

Fix

Case 4: Using Root Account for Everything

Cause

Fix

Case 5: Assuming AWS Configures Security Automatically

Cause

Fix

Security Considerations

Cost and Free Tier Awareness

Cleanup

Delete Test IAM User

Verify Deletion

Delete Additional Resources

Intermediate Extension Challenge

Skills Developed

Advanced / Professional Discussion

Multi-Account Strategy

Multi-Region Architectures

Advanced IAM