My Journey: From Computer Science Student to Full-Stack Developer
Introduction
Looking back at my journey from being a computer science student at KL University to becoming a full-stack developer has been nothing short of transformative. When I started my undergraduate degree in 2022, I had basic knowledge of C and HTML/CSS, but I never imagined I'd be building AI-powered recruitment platforms and working with companies like GAO Tek Inc. within just a few years.

In this post, I want to share my authentic journey - the struggles, the breakthroughs, the late nights debugging code, and the immense satisfaction of seeing your applications come to life.

The Foundation: Early Days (2022-2023)
Starting with the Basics
My programming journey began in high school with C programming and basic web technologies. Like many students, I started with:

C Programming: Learning fundamental concepts like loops, arrays, and functions
HTML/CSS: Creating simple static websites
JavaScript: Adding basic interactivity to web pages
The transition from these basics to modern web development felt overwhelming at first.

First Real Project: Smart India Hackathon 2023
My first significant exposure to real-world development came during the Smart India Hackathon 2023, where our team worked on HealthNest. This experience taught me:

// My first real JavaScript function - simple but meaningful
function validateHealthData(userInput) {
if (!userInput.age || !userInput.symptoms) {
return { valid: false, message: "Please provide all required information" };
}
return { valid: true, message: "Data validated successfully" };
}
Key Learnings:

Working in a team environment
Version control with Git (though I was terrible at it initially!)
Basic project structure and organization
The importance of user-centered design
The Learning Curve: Discovering Modern Web Development
Embracing React and the MERN Stack
In my second year, I discovered React, and it completely changed my perspective on web development. The component-based architecture made so much sense:

// One of my first React components
const StudentDashboard = ({ student }) => {
const [courses, setCourses] = useState([]);

useEffect(() => {
    fetchStudentCourses(student.id)
        .then(setCourses)
        .catch(console.error);
}, [student.id]);

return (
    <div className="dashboard">
        <h1>Welcome, {student.name}!</h1>
        <CourseList courses={courses} />
    </div>
);

};
The PFSD Hackathon 2024: CodeSync
Building CodeSync, a real-time collaborative code editor, was my first deep dive into:

Django: Backend development with Python
WebSockets: Real-time communication
Database Design: Proper data modeling

Real-time collaboration logic in Django

from channels.generic.websocket import AsyncWebsocketConsumer
import json

class CodeEditorConsumer(AsyncWebsocketConsumer):
async def connect(self):
self.room_name = self.scope['url_route']['kwargs']['room_name']
self.room_group_name = f'code_{self.room_name}'

    await self.channel_layer.group_add(
        self.room_group_name,
        self.channel_name
    )
    await self.accept()

async def receive(self, text_data):
    data = json.loads(text_data)
    # Broadcast code changes to all connected users
    await self.channel_layer.group_send(
        self.room_group_name,
        {
            'type': 'code_update',
            'content': data['content'],
            'user': data['user']
        }
    )

The Breakthrough: MERN Stack Mastery
FSAD Hackathon 2024: Video Streaming Platform
This project introduced me to Spring Boot and taught me about:

RESTful API design
File upload and streaming
Database optimization
Authentication and authorization
@RestController
@RequestMapping("/api/videos")
public class VideoController {

@PostMapping("/upload")
public ResponseEntity<VideoResponse> uploadVideo(
        @RequestParam("file") MultipartFile file,
        @RequestParam("title") String title,
        Authentication auth) {

    try {
        Video video = videoService.processAndSave(file, title, auth.getName());
        return ResponseEntity.ok(new VideoResponse(video));
    } catch (Exception e) {
        return ResponseEntity.badRequest()
            .body(new VideoResponse("Upload failed: " + e.getMessage()));
    }
}

}
MERN Hackathon 2025: NextHire - The Game Changer
Building NextHire, an AI-powered recruitment platform, was where everything clicked. This project combined:

Frontend: React with Redux for state management
Backend: Node.js with Express
Database: MongoDB for flexible data storage
AI Integration: OpenAI API for intelligent features
Real-time Features: Socket.io for live communication
// AI-powered resume parsing
const parseResume = async (resumeText) => {
try {
const response = await openai.chat.completions.create({
model: "gpt-3.5-turbo",
messages: [
{
role: "system",
content: "Extract structured data from this resume including skills, experience, education, and contact information."
},
{
role: "user",
content: resumeText
}
],
temperature: 0.3
});

    return JSON.parse(response.choices[0].message.content);
} catch (error) {
    console.error('Resume parsing failed:', error);
    return null;
}

};
Professional Experience: GAO Tek Inc.
Starting my internship at GAO Tek Inc. as a Full-Stack Developer has been incredible. Working on production applications taught me:

Professional Development Practices
// Clean, maintainable code with proper error handling
const authenticateUser = async (req, res, next) => {
try {
const token = req.headers.authorization?.split(' ')[1];

    if (!token) {
        return res.status(401).json({ 
            error: 'Authentication token required' 
        });
    }

    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    const user = await User.findById(decoded.userId);

    if (!user) {
        return res.status(401).json({ 
            error: 'User not found' 
        });
    }

    req.user = user;
    next();
} catch (error) {
    res.status(401).json({ 
        error: 'Invalid authentication token' 
    });
}

};
Key Technologies I Master Now
Frontend: React, Next.js, TypeScript, Redux, Framer Motion
Backend: Node.js, Express, Django, Spring Boot
Databases: MongoDB, MySQL, Firebase
Cloud: AWS, Azure, DigitalOcean
Tools: Git, Docker, Postman, VS Code, IntelliJ IDEA
Challenges and How I Overcame Them

1. Imposter Syndrome
   Challenge: Feeling like I didn't belong in tech spaces.
   Solution: Focusing on continuous learning and celebrating small wins.

2. Keeping Up with Technology
   Challenge: The rapid pace of technological change.
   Solution: Following tech blogs, joining developer communities, and hands-on practice.

3. Debugging Complex Issues
   Challenge: Spending hours on seemingly simple bugs.
   Solution: Learning systematic debugging approaches and using proper logging.

// From console.log debugging to proper logging
const logger = require('winston');

const processPayment = async (paymentData) => {
logger.info('Processing payment', {
userId: paymentData.userId,
amount: paymentData.amount
});

try {
    const result = await paymentGateway.charge(paymentData);
    logger.info('Payment processed successfully', { 
        transactionId: result.id 
    });
    return result;
} catch (error) {
    logger.error('Payment processing failed', { 
        error: error.message, 
        userId: paymentData.userId 
    });
    throw error;
}

};
Current Focus and Future Goals
What I'm Working On Now
Advanced React Patterns: Context API, Custom Hooks, Performance Optimization
System Design: Building scalable architectures
AI Integration: Exploring more AI/ML applications in web development
Open Source: Contributing to the developer community
Goals for 2025
Technical Leadership: Mentoring junior developers
Open Source Contributions: Building tools that help other developers
Content Creation: Sharing knowledge through blogs and tutorials
Startup Experience: Working on innovative products
Advice for Aspiring Developers

1. Start with Projects, Not Just Tutorials // Instead of just following tutorials, build something personal const myFirstProject = { name: "Personal Expense Tracker", technologies: ["HTML", "CSS", "JavaScript"], learnings: [ "DOM manipulation", "Local storage", "Event handling", "Basic CSS layouts" ] };

2. Embrace the Learning Curve
   Every expert was once a beginner. The key is consistency and not giving up when things get tough.

3. Build in Public
   Share your journey, your projects, and your learnings. The developer community is incredibly supportive.

4. Focus on Fundamentals
   // Understand the why, not just the how
   const deepEquals = (obj1, obj2) => {
   // Understanding object comparison at a deep level
   // helps with React re-renders, state management, etc.
   const keys1 = Object.keys(obj1);
   const keys2 = Object.keys(obj2);

   if (keys1.length !== keys2.length) {
   return false;
   }

   for (let key of keys1) {
   if (typeof obj1[key] === 'object' && typeof obj2[key] === 'object') {
   if (!deepEquals(obj1[key], obj2[key])) {
   return false;
   }
   } else if (obj1[key] !== obj2[key]) {
   return false;
   }
   }

   return true;
   };

5. Network and Connect
   Join developer communities, attend meetups (even virtual ones), and don't be afraid to reach out to people you admire.

Conclusion
My journey from a CS student to a full-stack developer has been filled with challenges, breakthroughs, and continuous learning. The key lessons I've learned are:

Consistency beats intensity: Regular practice is better than sporadic intense sessions
Build real projects: They teach you things no tutorial can
Don't be afraid to fail: Every bug is a learning opportunity
Stay curious: Technology evolves rapidly, and so should we
To anyone starting their journey in software development: you don't need to know everything to start. You just need to start, and learning will follow.

If you're on a similar journey or just starting out, I'd love to connect and share experiences. Feel free to reach out on LinkedIn or GitHub.

This post reflects my personal journey and experiences. Every developer's path is unique, and that's what makes our community so diverse and rich.

What's Next?
In my upcoming posts, I'll be sharing:

Technical deep dives into my projects
Code tutorials and best practices
Career advice for students and new developers
Behind-the-scenes of building production applications
Subscribe to stay updated with my latest posts and journey!