DEV Community: CodenificienT

The Aspiring AI Engineer: Educative Learning Path

CodenificienT — Tue, 28 Jul 2026 03:51:04 +0000

Published on Aug 28th, 2025

I've just finished Module 1: Learn Python from the Machine Learning Engineer Career Path on Educative.com, and I'm excited to share what I've learned! This foundational module has equipped me with the essential Python programming skills needed to tackle machine learning algorithms and data science projects.

🚀 What I Accomplished

Over the course of Module 1, I completed 40+ hands-on Python exercises that covered everything from basic syntax to building interactive applications. Each exercise was designed to reinforce programming concepts through practical, real-world scenarios.

📚 Core Concepts Mastered

1. Python Fundamentals & Syntax

Variables & Data Types: Learned to work with strings, integers, floats, and boolean values
Input/Output Operations: Mastered print() statements and input() functions for user interaction
Basic Operations: Arithmetic operations, string concatenation, and type conversion

Example from my work:

# Hello.py - My first Python program
print("Welcome to the Machine Learning course by Educative!!")

2. Control Flow & Decision Making

Conditional Statements: Implemented if, elif, and else statements for program logic
Comparison Operators: Used ==, !=, <, >, <=, >= for decision making
Logical Operators: Combined conditions with and, or, and not

Real-world application:

# Conditionals Movies.py - Age-appropriate movie recommendations
age = int(input("Enter your age: "))
if age >= 18:
    print("You can watch R-rated movies")
elif age >= 13:
    print("You can watch PG-13 movies")
else:
    print("You can watch PG movies")

3. Loops & Iteration

For Loops: Iterated through lists, ranges, and sequences
While Loops: Created programs that run until specific conditions are met
Loop Control: Used break and continue statements effectively

Practical example:

# While Loops.py - Interactive user input handling
while True:
    name = input("Enter your name (or 'quit' to exit): ")
    if name.lower() == 'quit':
        break
    print(f"Hello, {name}!")

4. Data Structures

Lists: Created, modified, and manipulated ordered collections
Dictionaries: Built key-value pairs for storing related information
Data Manipulation: Added, removed, and updated elements in collections

Hands-on practice:

# Lists.py - Working with collections
fruits = ["apple", "banana", "orange"]
fruits.append("grape")
print(f"Available fruits: {fruits}")

5. Functions & Code Organization

Function Definition: Created reusable code blocks with def statements
Parameters & Return Values: Built functions that accept input and produce output
Code Reusability: Organized code into logical, maintainable functions

Advanced function example:

# function adv layers.py - Interactive storytelling
def jungle_adventure():
    path = input("You find two paths: one goes to a river, the other to a mountain. Where do you go? ")

    if path == "river":
        print("You swim with dolphins!")
    elif path == "mountain":
        print("You find an ancient temple!")
    else:
        print("You wander into the savannah and get lost.")

jungle_adventure()

6. File Operations

Reading Files: Opened and processed data from text files
Writing Files: Created and updated files to store information
File Management: Handled file paths, error handling, and data persistence

Practical file handling:

# file diary.py - Personal journal system
with open("diary.txt", "a") as file:
    entry = input("Write your diary entry: ")
    file.write(f"{entry}\n")

7. Graphics & Visualization

Turtle Graphics: Created visual patterns and shapes using Python's turtle module
Color Manipulation: Applied different colors and styles to graphics
Geometric Drawing: Built hexagons, spirals, and complex patterns

Creative coding:

# graphics hexagon.py - Geometric art
import turtle
t = turtle.Turtle()
for _ in range(6):
    t.forward(100)
    t.right(60)

🎮 Interactive Projects Built

1. Temperature Converter

Built a comprehensive temperature conversion tool that handles Celsius, Fahrenheit, and Kelvin conversions with user-friendly menus and multiple conversion options.

2. Personal Habit Tracker

Created an interactive habit tracking system that allows users to:

Add multiple habits to track
Record daily completion status
View progress over time
Maintain streaks and motivation

3. Mini Chatbot

Developed a simple conversational bot that demonstrates:

User input processing
Conditional responses
Basic AI interaction patterns
Program flow control

4. Interactive Adventure Story

Built a text-based adventure game featuring:

User choice-driven narratives
Multiple story paths
Dynamic responses
Function-based story structure

💡 Key Learning Insights

1. Problem-Solving Approach

Break down complex problems into smaller, manageable pieces
Start with pseudocode before writing actual code
Test incrementally as you build features
Iterate and improve based on testing results

2. Code Organization

Functions are your friend - they make code reusable and maintainable
Meaningful variable names improve code readability
Comments matter - they help you and others understand your code
Consistent formatting makes debugging easier

3. User Experience

Clear prompts guide users through your programs
Error handling prevents crashes and improves usability
Feedback loops keep users engaged and informed
Intuitive interfaces make programs accessible to everyone

🔮 How This Prepares Me for Machine Learning

1. Algorithm Foundation

Control flow skills will be essential for implementing ML algorithms
Loop structures are crucial for training models and processing data
Conditional logic helps in decision trees and classification systems

2. Data Handling

File operations prepare me for reading datasets and saving results
Data structures knowledge is fundamental for working with NumPy arrays and Pandas DataFrames
Input processing skills will be needed for data preprocessing

3. Problem-Solving Mindset

Breaking down complex problems is exactly what's needed for ML model development
Testing and iteration mirrors the process of training and tuning ML models
User interaction skills will help in building ML applications and dashboards

🎯 What's Next: Module 2 Preview

With Module 1 complete, I'm now ready to tackle Module 2: Python Libraries, where I'll learn to:

Work with NumPy for numerical computing
Use Pandas for data manipulation and analysis
Create visualizations with Matplotlib and Seaborn
Apply data science techniques to real datasets

🏆 Key Takeaways

Python is powerful yet accessible - perfect for beginners entering the ML field
Hands-on practice is essential - theory alone isn't enough to build programming confidence
Building real projects accelerates learning - practical applications reinforce theoretical concepts
Foundation matters - strong Python skills will make learning ML libraries much easier
Problem-solving is a skill - it improves with practice and experience

💬 Final Thoughts

Module 1 has been an incredible foundation-building experience. Starting with simple "Hello World" programs and progressing to interactive applications has given me the confidence to tackle more complex machine learning challenges. The hands-on approach of Educative's platform has made learning Python engaging and practical.

I'm excited to continue this journey and can't wait to see how these Python fundamentals will translate into machine learning expertise. The road to becoming a Machine Learning Engineer is well-paved with these essential programming skills!

Ready to start your own ML journey? Check out the Machine Learning Engineer Career Path on Educative.com!

Tags: #Python #MachineLearning #Programming #Educative #LearningJourney #DataScience #Coding #MLCareerPath

Day 4 of Demolishing my Stack of Unfinished Projects: Secret Chat

CodenificienT — Tue, 28 Jul 2026 03:50:56 +0000

Published on Aug 21st, 2025

🚀 Made some progress

Welcome back to my "Demolishing My Stack of Unfinished Projects" series! This week, I'm excited to share the story of how I transformed a simple chat idea into a fully-featured, production-ready real-time messaging application called CodeniChat (formerly Secret Chat Bolt).

🎯 The Project That Started It All

Secret Chat began as one of those "wouldn't it be cool if..." moments. I had this idea for a secure, real-time chat application that could handle multiple rooms, user invitations, and password resets. You know the drill - you start with enthusiasm, then life happens, and suddenly it's been months with just a README file and some half-baked code.

But this week, I decided enough was enough. It was time to demolish this unfinished project and turn it into something I could actually be proud of. I started off with a short prompt into the bolt.new platform

🛠️ The Tech Stack That Made It Possible

Frontend

Next.js 15 - The latest and greatest React framework
React 19 - Cutting-edge React with the new compiler
TypeScript - Because type safety is not optional
Tailwind CSS - For rapid, beautiful UI development
shadcn/ui - Pre-built, accessible components

Backend & Database

Neon Database - Serverless PostgreSQL that scales with you
Drizzle ORM - Type-safe database operations
NextAuth.js - Secure authentication system
Bcryptjs - Password hashing and security

Real-time Features

Server-Sent Events - For real-time message updates
WebSocket-like functionality - Without the complexity

🚀 The Week-Long Development Sprint

Day 1: Foundation & Database

I started by setting up the database schema with Drizzle ORM. The beauty of using a modern ORM is that you can define your relationships once and let TypeScript handle the rest.

// Core tables for the chat system
export const users = pgTable("users", {
  id: text("id").primaryKey(),
  email: text("email").notNull().unique(),
  name: text("name").notNull(),
  password: text("password").notNull(),
  createdAt: timestamp("created_at").defaultNow(),
});

export const rooms = pgTable("rooms", {
  id: text("id").primaryKey(),
  name: text("name").notNull(),
  isPrivate: boolean("is_private").default(false),
  createdBy: text("created_by").references(() => users.id),
  createdAt: timestamp("created_at").defaultNow(),
});

Day 2: Authentication & User Management

NextAuth.js made implementing authentication a breeze. I added signup, signin, and even a password reset flow that generates secure tokens and handles the entire reset process.

The Password Reset Flow:

User requests reset → Secure token generated
Token stored with expiration → 24-hour validity
User clicks reset link → Token validated
New password set → Token marked as used

Day 3: Real-Time Chat Core

This was the fun part! I implemented the core chat functionality with:

Message grouping - Consecutive messages from the same user are visually grouped
Auto-scroll - Intelligent scrolling that doesn't interfere with user reading
Room management - Public and private rooms with automatic user assignment

Day 4: The Invitation System

One of the most requested features in any chat app - the ability to invite users to rooms. I built:

Invite modal - Select users from a filtered list
Pending invitations - Sidebar display of received invites
Accept/Decline actions - One-click room joining

Day 5: UI/UX Polish & Branding

I transformed the generic "ChatApp" into CodeniChat with:

Custom favicon - SVG-based chat icon
Responsive design - Works on all devices
Modern UI components - Using shadcn/ui for consistency
Footer addition - Copyright and "made with love" message

Day 6: Next.js 15 Upgrade

This was a significant milestone. I upgraded from Next.js 13 to Next.js 15, which involved:

React 19 upgrade - Latest React features
TypeScript improvements - Stricter type checking
Build optimization - Better performance and smaller bundles

Day 7: Deployment & Final Touches

The final day was all about getting this baby deployed:

Vercel configuration - Optimized for Next.js 15
Environment setup - Secure configuration management
Final testing - Ensuring everything works in production

🎨 Key Features That Make This App Special

1. Intelligent Message Grouping

const groupedMessages = useMemo(() => {
  return messages.reduce((groups: GroupedMessage[], message, index) => {
    const prevMessage = messages[index - 1];
    const nextMessage = messages[index + 1];

    const isFirstInGroup =
      !prevMessage ||
      prevMessage.user.id !== message.user.id ||
      message.createdAt.getTime() - prevMessage.createdAt.getTime() >
        5 * 60 * 1000;

    // Group logic implementation...
  }, []);
}, [messages]);

2. Smart Auto-Scroll

The app intelligently detects when users are reading older messages and won't force-scroll them to the bottom. But when they're at the bottom, new messages automatically appear.

3. Room Invitation System

Users can invite others to private rooms, and pending invitations are clearly displayed in the sidebar with accept/decline buttons.

4. Password Reset Flow

Complete password recovery system with secure token generation and validation.

🚧 Challenges I Faced (And How I Overcame Them)

1. Next.js 15 Compatibility Issues

Problem: The upgrade introduced breaking changes in API routes and required new Suspense boundaries.

Solution: I updated all API route parameters to use Promise<{ roomId: string }> and wrapped components using useSearchParams() in Suspense boundaries.

2. Vercel Deployment Issues

Problem: Next.js 15 peer dependency conflicts during deployment.

Solution: Used npm install --legacy-peer-deps in the build process and configured vercel.json accordingly.

3. Real-Time Message Updates

Problem: Implementing real-time features without WebSockets.

Solution: Used Server-Sent Events with a custom hook that handles reconnection and message buffering.

📊 What I Learned

1. Modern React is Incredible

React 19 with the new compiler is a game-changer. The performance improvements and developer experience are noticeable from day one.

2. TypeScript + Drizzle = Database Bliss

Having type-safe database operations eliminates entire classes of bugs. I can't imagine building a production app without this combination.

3. Component Libraries Save Time

shadcn/ui provided beautiful, accessible components that I could customize while maintaining consistency. This saved me hours of CSS work.

4. Incremental Development Works

By building features one day at a time, I was able to test and refine each component before moving to the next. This prevented the "everything is broken" syndrome.

🎯 What's Next for CodeniChat?

While this project is now "complete" in terms of core functionality, I'm already thinking about future enhancements:

File sharing - Upload and share images, documents
Voice messages - Audio recording and playback
End-to-end encryption - For truly private conversations
Mobile app - React Native version
Push notifications - For important messages

🏆 The Result: A Project I'm Actually Proud Of

Secret Chat Bolt went from being another unfinished project in my stack to a fully-functional, production-ready chat application. Here's what I accomplished in just one week:

✅ Complete authentication system

✅ Real-time messaging

✅ Room management

✅ User invitations

✅ Password reset flow

✅ Modern, responsive UI

✅ Next.js 15 + React 19

✅ Production deployment

💡 Key Takeaways for Fellow Developers

1. Start Small, Build Incrementally

Don't try to build everything at once. Pick one feature, implement it completely, then move to the next.

2. Use Modern Tools

Next.js 15, React 19, and Drizzle ORM made this project enjoyable instead of frustrating.

3. Focus on User Experience

Little details like message grouping and smart scrolling make a huge difference in how users perceive your app.

4. Deploy Early and Often

Getting your app running in production early helps identify issues you won't catch in development.

🔗 Project Links

Live Demo: [Your deployed URL]
GitHub Repository: [Your repo URL]
Tech Stack: Next.js 15, React 19, TypeScript, Neon DB, Drizzle ORM

🎉 Conclusion

Secret Chat Bolt is no longer part of my unfinished projects stack. It's a living, breathing application that people can actually use. The satisfaction of completing a project like this is incredible, and it's motivated me to tackle the next unfinished project in my stack.

Remember: Every finished project started as an unfinished one. The key is to break it down into manageable pieces and tackle them one day at a time.

What's the next unfinished project in your stack that you're going to demolish? Let me know in the comments below!

This post is part of my "Demolishing My Stack of Unfinished Projects" series, where I tackle one unfinished project per week and turn it into something I can be proud of. Follow along for more project completion stories, technical deep-dives, and lessons learned from the trenches of software development.

Tags: #NextJS #React #TypeScript #ChatApp #FullStack #WebDevelopment #ProjectCompletion #RealTimeChat #Database #Authentication

Day 3 of Demolishing my Stack of Unfinished Projects: SmartNotes Project

CodenificienT — Tue, 28 Jul 2026 03:50:49 +0000

Published on Aug 18th, 2025

The Setup: When Everything Seems Perfect

After successfully implementing a chatbot based on ChatGPT in my portfolio (as detailed in my previous "Redesign Portfolio" post), I was feeling pretty good about myself. The AI integration was working smoothly, users could ask questions about my skills and projects, and I had successfully created content embeddings that made the chatbot intelligent and contextually aware.

Little did I know that this "completed" project was about to become the perfect candidate for my "Unfinished Projects" series.

The Crisis: When OpenAI Goes Silent

It started with a simple error message: "OpenAI API account suspended." At first, I thought it was a simple configuration issue. Maybe I had accidentally exposed my API key or hit some rate limit. But after checking my environment variables and account status, I realized the problem was deeper.

My OpenAI account was suspended, and suddenly, my "completed" AI chat functionality was completely broken. Suddenly, my SmartNotes app which also powers the chat functionality went offline.

This was supposed to be a finished project. Instead, it had become the latest addition to my stack of unfinished work.

The Panic: Scrambling for Solutions

The immediate challenge was clear: either abandon the chat functionality entirely or find an alternative solution. Given that I had already invested significant time in building the user interface and database integration, abandoning it wasn't an option.

I started researching alternatives:

Claude API: Limited availability and different pricing structure
Local AI models: Required significant computational resources
Hugging Face: Promising, but I had no experience with their inference API

The clock was ticking, and my portfolio was broken.

The Discovery: Hugging Face to the Rescue

After several hours of research and testing, I discovered that Hugging Face offered inference APIs that could potentially replace OpenAI's functionality. The catch? I had to completely rewrite the AI integration layer.

This wasn't just a simple API swap - it was a complete architectural overhaul. I had to:

Replace OpenAI's embedding model with Hugging Face alternatives
Find a suitable text generation model
Handle different response formats
Implement proper error handling for a new service

The Implementation: Building Resilience

Model Selection Hell Finding the right model on Hugging Face proved more challenging than expected. My first attempts failed spectacularly:

microsoft/DialoGPT-medium - "No inference provider available"
gpt2 and distilgpt2 - Limited conversational capabilities
Qwen/Qwen3-4B - Finally worked with the nebius provider

Database Architecture Evolution The migration also exposed a fundamental issue: my MongoDB setup wasn't ideal for production use. I decided to migrate to Neon PostgreSQL, which meant:

Updating Prisma schema
Migrating existing data
Handling different ID types
Testing the new connection

Streaming Responses: The Silver Lining One positive outcome was implementing streaming text responses. Instead of waiting for complete AI responses, users now see text appear word-by-word, creating a ChatGPT-like experience that's actually better than the original implementation.

The Fallback System: Never Trust a Single Service

I learned a valuable lesson about building robust systems. I implemented a multi-layered fallback approach:

Vector Search: Primary method using Pinecone embeddings
Text Search: Fallback to simple text matching
Intelligent Responses: Pre-built responses for common queries

This ensures that even if the AI service fails, users still get helpful responses.

The Current State: Better Than Before

What started as a crisis has evolved into a more robust, scalable system. The new implementation includes:

✅ Hugging Face AI integration via Nebius
✅ Streaming text responses
✅ PostgreSQL database backend
✅ Comprehensive error handling
✅ Multiple fallback mechanisms

Lessons Learned: Why This Project Wasn't Really "Finished"

Single Point of Failure: Relying on one AI service provider is risky
Production vs. Development: What works in development might fail in production
Resilience by Design: Building fallback systems from the start saves time and maintains user experience
The Definition of "Complete": A project isn't truly finished until it can handle real-world failures gracefully

The Unfinished Projects Paradox

This experience taught me something important about my "Unfinished Projects" series. Sometimes, what appears to be a finished project is actually just waiting for the right failure to reveal its incompleteness.

The AI chat integration wasn't truly finished until it could survive the loss of its primary service provider. In that sense, the "unfinished" phase was actually a blessing - it forced me to build something more robust than I originally planned.

What's Next: The Never-Ending Journey

Even now, I'm not sure this project is truly "finished." I'm already planning improvements:

User analytics for chat interactions
Conversation history persistence
Multi-language support
Integration with more AI models

Conclusion: Embracing the Unfinished

This project taught me that "unfinished" isn't always a negative state. Sometimes, it's the catalyst for building something better than originally envisioned. The AI chat integration that almost wasn't has become one of my portfolio's most resilient features.

For developers facing similar challenges, remember: every obstacle is an opportunity to improve your architecture. What seems like a setback might actually be pushing you toward a better solution.

The journey from "finished" to "unfinished" to "better than finished" is what makes development exciting. Embrace the chaos, build resilience, and never stop improving.

Technical Stack Used:

Next.js 15.0.0
Hugging Face Inference API
Neon PostgreSQL
Prisma ORM
Pinecone Vector Database
Streaming text responses
Multi-layered fallback system

Resources:

This blog post captures the emotional journey, technical challenges, and valuable lessons learned while maintaining the honest, problem-solving tone that your "Unfinished Projects" series is known for. It shows how "unfinished" can actually lead to better outcomes!

16 Redesigning my Portfolio Website

CodenificienT — Tue, 28 Jul 2026 03:50:42 +0000

Published on Aug 18, 2025

A New Era of AI-Powered Coding Begins

I have installed Cursor on my laptop this weekend, and I am amazed at how much it speeds up my coding. I have a new debugging buddy!!

This week, I have made several updates to the Portfolio website.

The Challenge: When OpenAI Falls Short

In my previous post, I shared the excitement of implementing a chatbot based on ChatGPT for my portfolio website. The initial experience was promising - I successfully created content embeddings and integrated them with OpenAI's API. However, as many developers know, relying on a single service provider can lead to unexpected roadblocks.

When my OpenAI account encountered issues, I faced a critical decision: abandon the chat functionality or find an alternative solution. I chose the latter, embarking on a journey that would transform my portfolio's AI capabilities and teach me valuable lessons about building robust, fallback-ready systems.

The Migration: Embracing Open Source AI

The transition from OpenAI to Hugging Face wasn't just a simple API swap - it was a complete architectural evolution. Here's what I learned:

1. Model Selection Complexity Finding the right model on Hugging Face proved more challenging than expected. After testing several options:

microsoft/DialoGPT-medium - No inference provider available
gpt2 and distilgpt2 - Limited conversational capabilities
Qwen/Qwen3-4B - Perfect fit with the nebius provider

2. Database Architecture Evolution The migration also prompted a database upgrade from MongoDB to Neon PostgreSQL. This wasn't just about changing providers - it was about building a more scalable, production-ready foundation for my portfolio.

Technical Implementation: Building Resilience

Streaming Responses for Better UX One of the most significant improvements was implementing streaming text responses. Instead of waiting for complete AI responses, users now see text appear word-by-word, creating a ChatGPT-like experience:

// Streaming implementation with word-by-word appearance
const stream = new ReadableStream({
  start(controller) {
    const encoder = new TextEncoder();
    const words = response.split(' ');

    words.forEach((word, index) => {
      setTimeout(() => {
        controller.enqueue(encoder.encode(word + ' '));
        if (index === words.length - 1) {
          controller.close();
        }
      }, index * 100);
    });
  }
});

Robust Fallback System I implemented a multi-layered fallback approach:

Vector Search: Primary method using Pinecone embeddings
Text Search: Fallback to simple text matching
Intelligent Responses: Pre-built responses for common queries

User Experience Improvements

Input Focus Management Users can now have continuous conversations without losing focus:

useEffect(() => {
  if (inputRef.current) {
    inputRef.current.focus();
  }
}, [messages]);

Response Filtering Hidden internal AI processing tags for cleaner output:

const cleanResponse = response.replace(/<think>.*?<\/think>/gs, '');

Performance & Scalability

Database Optimization

Migrated from MongoDB to Neon PostgreSQL
Updated Prisma schema for better type safety
Implemented proper ID handling for vector search

API Efficiency

Reduced response times with streaming
Implemented proper error handling
Added comprehensive logging for debugging

Lessons Learned

Always Have a Plan B: Building fallback systems from the start saves time and maintains user experience
Open Source is Powerful: Hugging Face provides enterprise-grade AI capabilities without vendor lock-in
User Experience Matters: Small details like input focus and streaming responses significantly improve perceived performance
Database Architecture: Choosing the right database from the start prevents migration headaches later

Current Status & Future Plans

The chat functionality is now fully operational with:

✅ Hugging Face AI integration via Nebius
✅ Streaming text responses
✅ PostgreSQL database backend
✅ Robust error handling
✅ Clean, professional UI

Next Steps:

Implement user analytics for chat interactions
Add conversation history persistence
Explore multi-language support
Integrate with more AI models for specialized responses

Conclusion

This migration taught me that technical challenges often lead to better solutions. What started as a simple API replacement evolved into a more robust, scalable, and user-friendly chat system. The journey from OpenAI to Hugging Face wasn't just about solving a problem - it was about building something better.

For developers facing similar challenges, remember: every obstacle is an opportunity to improve your architecture and learn new technologies. The result is often a more resilient and feature-rich application.

Technical Stack Used:

Next.js 15.0.0
Hugging Face Inference API
Neon PostgreSQL
Prisma ORM
Pinecone Vector Database
Tailwind CSS
TypeScript

Resources:

This blog post captures the technical journey, challenges faced, and solutions implemented while maintaining the professional tone and technical depth that your readers expect. It also provides valuable insights for other developers who might face similar migration challenges.

15 Redesigning my portfolio website

CodenificienT — Tue, 28 Jul 2026 03:50:35 +0000

Published on Jun 21st, 2025

Thanks, NeonDB !

I just started using NeonDB thanks to their generous free tier. I have migrated the SmartNotes application to NeonDB and recreated the notes.

June 19th, 2025 Update

On Juneteenth, I started the migration process to Neon DB. I rewrote the Prisma queries and updated the database links. The app is able to generate a new Prisma client and create new tables on the remote database.

June 20th, 2025 Update

The chat application works again for the SmartNotes app. However, there are lots of error messages in the Terminal, and I am not ready to deal with those right now. Will follow up on the next post..

14 Redesigning my Portfolio website

CodenificienT — Tue, 28 Jul 2026 03:50:28 +0000

Published on Jun 20th, 2025

Currently the chat functionality on my portfolio is down because my website was probably accessed from abroad and my Open AI account got suspended.

Read the fine print

My account violated the terms of use which I did not read. I am now in the process of using some open source alternatives to get my chat functionality working again.

I also moved a few portfolio applications away from Supabase to Neon and the chat database to Neon from MongoDB. I am still relying on Pinecone to store my vector embeddings. I can see a future enhancement where I store everything in the Neon thanks to pgvector to reduce my dependencies.

June 20th, 2025 Udpate

I worked on the portfolio for a few hours today. I am trying to swap out OpenAI and replace with HuggingFace. The inference website does not seem to work because there’s a mismatch between our OpenAI embeddings and the current version of the SmartNotes app.

Recap: We created a note taking application called SmartNotes which has a chatbot. Trying to copy over the same code to my portfolio to so that both apps are using the same notes and the same database.

I will recreate the Pinecone index using a different embedding model and reconnect to HugggingFace.

13 Redesigning my Portfolio Website

CodenificienT — Tue, 28 Jul 2026 03:50:22 +0000

Published on Jan 17th, 2024

Added Chat functionality

I recently created a chatbot based on ChatGPT where I learned to create content embeddings to empower ChatGPT to chat with our data. The experience went as well as could be expected.

I have added more information from my portfolio website to the Pinecone vector store and now the same chatbot is functional on tioye.dev

Removed the Chat page

Since the chatbox is a popup window mimicking the chatbots on familiar websites, I have removed the initial placeholder chat page from the website. I have upgraded the navigation link to a button that triggers that chat window. Therefore, the Chat functionality can be triggered from any page. When the chat window is covering information on a page, the window can be closed and reopened without losing the conversation data.

Open chat

Currently, the chatbot can answer questions about my portfolio, and is based on GPT 3.5 turbo. I do not require login to use the chat. I do not anticipate many visitors using the chat functionality, and this should be good for several months

12 Redesigning my portfolio website

CodenificienT — Tue, 28 Jul 2026 03:50:15 +0000

Published on Jan 4th, 2024

The new version of the portfolio is live

I have completed the Landing, Resume and Blog pages and I have edited the domain names on Vercel to point to tioye.dev. The previous build on Vercel is officially retired.

New Landing Page, New Beginnings

The theme is light mode by default. The deployed site feels faster and there is a big button to download a PDF copy of my resume.

Next steps

Now that my updated portfolio is live, my free time going forward will be split between the AWS certification prep work, interview preparation, job applications / coding challenges, fixing the broken portfolio projects, and adding an AI powered chatbot to the portfolio.

My Newly Deployed site

My world in 2023

CodenificienT — Tue, 28 Jul 2026 03:50:08 +0000

Published on Dec 31st, 2023

A summary of the major events

Graduation: Class of 2023

The 2023 year ended on a high note for me as I have completed grad school with my Master degree in Computer Science. Before I start freaking out about job interviews, and my 6-figure student loan, it would be a great time to reminisce about the major events that have shaped the past year.

Facing deportation?

Early in January 2023, I was panicking about the registration deadline at the University of Louisville. The automated system was not allowing me to register for my classes due to the unpaid tuition balance from the previous Fall semester. Past the registration deadline, I would miss the semester, which would have several implications for my immigration status and student visa. It was a worrisome situation which was remedied at the last minute. I started classes a week late

Summer of Uncertainty

I got a 3.5 gpa during the Spring 2023 semester and was ready for my final semester. The remaining tuition balance from the Spring semester now remains to be paid. This time, there was no big check to provide to the bursar. I spent the summer trying several solutions. My income from the part time internship under the CPT was sufficient to make a small dent on the balance. I have considered selling my vehicle, but the offers were too low. The final solution came from the graduate school as they found some scholarship funds which they applied towards the tuition balance to allow me to register for my final semester. I feel fortunate about this outcome and will be empowered to pay it forward some day.

Graduated, now what?

Getting my master was the hardest thing I have ever done. There was a time that felt like everything that could have gone wrong has gone wrong. But I have persevered until I completed what I have started. I feel like if I can get through that, then I can get through anything! I am ready to go to many job interviews, until I land my first tech role. Bring it on!

11 Redesigning my portfolio website

CodenificienT — Tue, 28 Jul 2026 03:50:02 +0000

Published on Dec 29th, 2023

Enter TypeScript and Next.js 14

I am continuing the process of visually overhauling my portfolio website. A few weeks after upgrading my site to Next.js, I have started using TypeScript for my web applications. I have spent the Fall semester finishing my master's degree, and contemplating several ways I can improve my portfolio website.

I am now a recent graduate applying for my first full-time role in tech, and upgrading my portfolio site to TypeScript along with several visual improvements is a must.

Old Version

New Version

New Version with Dark Mode

I have added a dark mode toggler to the improved navigation bar and I am planning to remove a few pages. I plan to add a chat page based on a vector database of my bio so users can chat with my data.

Another noteworthy improvement is that the inclusion of TailwindCSS has reduced my coding time dramatically. It took me a week to get the main user interface working last time. This time, less than an hour. I already feel like a 10x developer :)!

Coming Soon!

For now, I am deploying the new version of my portfolio on a separate vercel endpoint https://tioyedev2024.vercel.app/ and my website https://tioye.dev/ still points to previous build. I plan to make the switch once the 3 main pages, Landing, Resume and Experience, are deployed on the new endpoint

10 Redesigning my portfolio app

CodenificienT — Tue, 28 Jul 2026 03:49:55 +0000

Published on Mar 16th, 2023

Hashnode connected

Today I followed the incredibly useful blog post by CatalinPit and I connected my portfolio blog directly to Hashnode, skipping GraphCMS. This negates the need to create a duplicate post in GraphCMS after posting on Hashnode.

Revalidate: 600

I have kept the default refresh period in Vercel to 10 minutes. New blog posts on Hashnode will show up on my portfolio within 10 minutes, provided the Vercel platform rebuilds the new page in sub-30 seconds as usual.

GitHub actions untouched

I have not messed with anything I have already set up in GitHub. My latest blog should be synched to my GH profile every sunday as usual

One caveat

The GraphCMS version of my blog was based on blog series which are almost mirrored from Hashnode. Unfortunately, the Series feature was glued onto Hashnode after the fact and the GraphQL API does not support fetching blogs based on blog series. I have attempted a simple fetch to grab the blog series, but I was getting error messages. Currently, I have removed the blog series header from the portfolio site. I have replaced the series badge on each blog post with an avatar of the author, aka, yours truly!

1 Startup Series: Connecting my Admin frontend to the backend

CodenificienT — Tue, 28 Jul 2026 03:49:48 +0000

Published on Feb 16th, 2023

My solar energy startup platform FasoLara has reached a new milestone recently and I decided to start a new blog series about it!

The project management platform has been a long journey since I published my first commit to GitHub in October 2020. What started based on a simple idea quickly became a behemoth of a software engineering project for my beginner programmer skills. I have poured thousands of hours into research, tutorials and coding to figure out how to put something like this together. Since then, I have made multiple changes to the FasoLara repository.

The platform is currently open source, but I am using a private fork to publish the 3 different components to the Vercel platform. I had a basic demo of the admin dashboard with 6 pages before I removed all the sample data, then upgraded everything to the app directory in NextJS 13 and connected the dashboard to the backend server featuring Apollo GraphQL server v4.

Yesterday, February 15th, 2023, I added Next-Auth to handle authentication. Initial testing of the next-auth version seems to work with the appDir in Next.JS 13. It is far from the login experience that I want. It will take more effort to iron out the details because proper documentation is still rare

Lots of testing needs to be done

Although I have successfully connected the Cypress testing framework to the frontend app, I have yet to do the same on the admin app. I am managing a lot of complexity with lots of new packages.

Every mistake under the sun

I have lost count of how many times I made breaking changes to the code base trying to implement new features on the main branch only to hard reset the branch after tens of hours of work that I could have done on a new branch instead. I can say that I am moving fast and breaking things per facebook's motto!

Mobile app on the backburner

I have 3 sample pages that I made on the mobile application. I would have liked to have at least a fully functional landing page on the React Native application component by now, but that might take a while since I can only focus on breaking one thing at a time! I have not finished the Figma designs of the mobile application. Now that I have a decent idea of the backend server capabilities and have dozens of detailed GraphQL schemas to support it, I can make more progress on building the server and admin dashboard in lockstep. Later, when I get stuck on both of those, I will switch my attention to the mobile application. I think once I have a functional admin dashboard which is the centerpiece of the platform, mobile development will benefit greatly from the experience.

Fun while it lasted

I have enjoyed crafting some of the User Interface components from scratch and learning how to put together primitive components using JSX and SASS, it has become quickly obvious that I was spending time on the less important things. I have recently added ChakraUI to my tech stack and the increasing number of available ready-to-go components in Chakra has accelerated development considerably. The project contains enough complexity for a lifetime, and it was refreshing to move away from getting lost in some of the smaller weeds so I can focus on sorting out getting lost in some of the bigger weeds such as authentication and role-based authorization using NextAuth and a homemade authentication scheme based on GraphQL.

Battle of Syssiphus

Building so many separate applications within the same platform feels like a battle of Syssiphus based on the sheer amount of work that needs to be done and redone. I can say I have rebuilt the admin dashboard 2 or 3 times already. The irony of duplicating work by trying to avoid duplicated work. But I also know that duplicating work 2-5 times is much better than duplicating that work on 20 different pages, some of which will need to be redone a few more times in the future based on updates in the backend and changes done to the underlying MongoDB document models.

Next steps...

I look forward to a shorter blog post in the next article where I document how I managed to get authentication 'working' on the admin dashboard. It feels good to see how things are shaping up since I had no idea I could pull off all the progress made so far. Upgrading the entire project to TypeScript was such a huge surprise based on how little TypeScript I know and how it took less than 10 hours in total to get the whole project converted to TypeScript. It's all on the up and up from here!!!