Overcoming Integration Challenges and Advancing JAICE’s Beta Stage

This week had its fair share of ups and downs as we worked to integrate the Stage 0 – Binary Classifier into JAICE. Up until now, most of my testing had been in a standalone environment, so this was the first big push to connect the model directly with our email pipeline and start classifying messages as “job-related” or “not job-related.”

Unfortunately, things didn’t go smoothly at first. The model wasn’t properly connecting to the incoming email data, which meant nothing was being sorted correctly. After some debugging and a lot of back-and-forth testing, it became clear that the issue wasn’t with the model itself, but with how it was being integrated into our system.

Thankfully, after collaborating with my teammate, we were able to work through the problem. Through a bit of collaborative troubleshooting and brainstorming, he managed to get the connection stable and the model running properly within the pipeline. It was one of those moments that reminded me why teamwork is so valuable — sometimes a fresh set of eyes and a new perspective can make all the difference.

To be aware and present with each other at work is to create an environment where everyone can thrive. — Dalai Lama

Outside of integration, I also updated our README.md to reflect where we currently stand in the project. JAICE is now officially in its Beta development stage, where we’re beginning to integrate our NLP components and build out the staged system for parsing and classifying job-related data. It’s exciting to see everything moving from theory and isolated testing to a fully connected, functioning application.

Even though we hit a few bumps this week, we made real progress. Debugging and collaboration were the themes for this week — and both pushed us closer to a smarter, more complete version of JAICE.

Optimizing Email Classification with AI Models

This week was another deep dive into model testing — lots of experimentation, analysis, and fine-tuning. After last week’s shift to a stage-based AI approach, my main goal was to start identifying which models perform best for our Stage 0 classification, the step responsible for sorting emails into “job-related” or “not job-related.”

I’ve been running tests in an independent testing environment to keep things isolated from the main JAICE system, and I finally started seeing some promising results. The valhalla/distilbart-mnli-12-3 model has been the most efficient option I’ve tested so far. On average, it processes around 200 emails in 50 – 53 seconds and classifies everything in about 2 – 3 minutes total, which is a HUGE improvement compared to earlier approaches.

At first, the model’s accuracy wasn’t great, but after some tuning, I found that it performed best with thresholds around 0.70. From there, I built a hybrid system that uses a mix of keyword matching and job-domain heuristics to double-check the predictions. This extra layer helps catch false positives — emails that are clearly not job-related but are worded differently than the model expects.

Next week, I’ll begin testing this setup directly within the JAICE project environment instead of a standalone tester. That will give me a better sense of how it performs in real use, especially when paired with live email data and the rest of the pipeline. I also plan to keep refining the thresholds and heuristics to push the accuracy even higher.

Overall, this week was about progress through iteration. Every round of testing gets us closer to a reliable foundation for JAICE’s email classification system. It’s exciting to see the model evolve from early prototypes into something that’s actually fast, functional, and production-ready.

Pivoting AI Models: From One-Step to Specialized Stages

If I had to sum up this week in one word, it would be RESEARCH (well, actually it would be three words: research, testing, and research!!) This week was all about digging deep into how our AI models will function within JAICE and figuring out the most efficient and accurate approach for classifying emails and extracting recruiter information.

Initially, I tried building what I called the “all-encompassing” one-step model. Basically, the idea was to have a single model handle everything in one go: from determining if an email was job-related, to classifying its stage (applied, interview, offer, etc.), and even performing entity extraction. In theory, it sounded great. In practice? Not so much.

The biggest issue was performance and efficiency. Running this one-step model on CPU took anywhere from 30-45 minutes per test, and even then, the results weren’t as accurate as we needed. Because it was trying to do everything at once, the model struggled to stay consistent and often misclassified messages that were close in context but different in meaning. It was slow, heavy, and just not scalable for what we’re building.

After a lot of testing and reflection, I decided to pivot to a staged approach. Now, instead of one big model doing everything, the AI work is split into multiple specialized stages:

1. Classification Model – Identifies whether an email is job-related and classifies its stage (e.g. Applied, Interview, Offer, etc.).
2. NER (Named Entity Recognition) Model – Extracts recruiter names, company info, and job titles from the email text.

This new approach is already proving to be faster and easier to test independently. It also opens the door for more flexibility; we can retrain or improve one stage without it affecting the others.

Most of this week was spent experimenting, documenting results, and validating which configurations gave the best accuracy-to-speed balance. It wasn’t the flashiest week, but it was a huge one in terms of laying the groundwork for JAICE’s AI integration.

Overall, this week reminded me how much trial and error goes into making something efficient and reliable. The one-step model might not have worked out, but the insights from that testing led me to a much smarted, modular direction for JAICE’s AI moving forward.

Implementing Firebase Authentication in JAICE

This week was all about adding real functionality to JAICE. After weeks of focusing on structure, styling, and layout polish, we’ve officially started integrating the systems that will bring our platform to life… starting with Firebase Authentication.

My main focus was setting up sign-in and sign-up functionality and making sure everything connected smoothly between the frontend and backend. I configured Firebase to handle user authentication using email and password, then set up environment variables to keep our keys secure. Once everything was wired up, I tested the authentication flow to confirm that new accounts could be created and existing users could log in without errors.

With authentication in place, I worked on routing users to the authenticated version of the About page after a successful login. This required setting up protected routes that verify a user’s session before allowing access to specific pages. It was a great step forward in moving from static content to a personalized experience that responds to user state. Seeing the About page load dynamically for signed-in users really made the app start to feel “real.”

Beyond coding, our team synced up to discuss next steps for Firebase integration and how we’ll connect user data to other parts of JAICE, like the dashboard and profile sections. We also reviewed some UI details to make sure the authentication screens stay consistent with our existing design system — clean layouts, readable text, and smooth transitions.

Overall, this week represented a major milestone: JAICE now has secure authentication and dynamic routing in place. We’re officially moving past static prototypes and into a functioning product environment. Each update makes the platform feel more tangible, and it’s exciting to watch it evolve piece by piece.

Transforming Designs into a Functional App: Key Updates

This week marked a big shift for JAICE — we officially started turning our designs into a working application. After spending the last few weeks planning, refining the backlog, and finalizing our UI in Figma, it was really satisfying to finally start coding and seeing the vision take shape.

My main focus was the About page, which has been one of the most detailed and visually rich screens in the app. I started translating the layout from Figma into React components, making sure the text, imagery, and transitions captured the same flow we designed. During that process, I ran into a few layout issues — mainly with the scroll behavior and header sizing. The page wasn’t scrolling properly at first, and the header felt off compared to the rest of the sections.

After a little troubleshooting, I discovered the culprit; our global layout was set to overflow-hidden, which prevented vertical scrolling entirely. Changing it to overflow-x-hidden fixed the issue instantly, allowing natural page scrolling while still keeping horizontal overflow contained. From there, I fine-tuned the header’s padding and font sizing to make sure it lined up visually with the rest of the content. Those small adjustments made a huge difference in both usability and design consistency.

Another thing I worked on for the About page, I made some refinements to the Impact section, adjusting how the image scales and aligns alongside the text. The goal was to make everything feel cohesive across screen sizes without losing the visual balance we established in Figma.

To wrap up the week, I synced up with the team to review the updates and make sure the new structure works seamlessly with our next development goals. We’re moving into a stage where JAICE is no longer just a concept — it’s becoming a living, functional product.

Overall, this week was about momentum and problem-solving. Fixing those layout issues and seeing the About page come to life in real time was a great reminder that even small details make a big difference in creating a polished, user-centered experience.

Week 4: Preparing JAICE for Development

This week was all about tying up loose ends and making sure JAICE is in a good spot before we officially roll into development in the coming week. On the Jira side, I put together a proposed sprint so we could start mapping out what our first chunk of development work will look like. It gave us a clearer picture of priorities and helped the team visualize how the backlog translates into actual tasks.

One of the bigger things I tackled this week was the Settings screens. The first version split everything into three separate tabs: Account, Notifications, and Accessibility. It looked clean, but the problem was that it felt empty and forced users to click around more than they should have. Basically, it wasn’t hitting the mark for usability or flow.

So, I reworked the layout. Now, each settings area has more depth and feels like a proper screen instead of just a placeholder. The Accounts Settings include profile details, linked accounts, and security options like two-step verification. The Notifications Settings let users toggle between in-app, email, and SMS alerts without digging through multiple screens. And the Accessibility Settings now support contrast adjustments, text scaling, and reduced motion — all organized in one place. The redesign makes the whole experience smoother and feels a lot closer to the professional polish we’re aiming for.

Account Settings – Default Menu

Account Settings – Expanded Menu

Notification Settings – Default Menu

Notification Settings – Expanded Menu

Accessibility Settings – Default Menu

Accessibility Settings – Expanded Menu

To wrap things up, I exported the updated screens from Figma, formatted them in Canva with quick descriptions, and zipped them into a package for the team. We also met up to go over edits, make a few last calls, and line everything up before development kicks off.

Overall, this week was about spotting problems early and turning them into improvements. The settings updates not only fix the gaps we had but also set a stronger standard for the rest of the app. With the sprint plan drafted and designs finalized, we’re in a solid spot to hit the ground running next week.

Week 3: Strengthening JAICE Through Organization and Design

This week was a pivotal one for JAICE, our job application management platform designed to streamline and improve the hiring process for job seekers. A large part of my contribution involved strengthening our organizational backbone by helping populate the Jira backlog and connecting tasks to our FigJam planning board. This ensured our sticky-note brainstorming transitioned into tangible development tickets. By adding around sixty new backlog items, I helped expand coverage of both feature enhancements and support tasks, which will guide our sprint planning and keep the team aligned.

I also focused on the design and user experience side of JAICE. Using Figma, I explored ideas for the About and Notifications screens, paying close attention to how transitions and animations could add polish to the experience. For example, the About section is being reimagine as a vertically scrolling journey, spotlighting each teammate with smooth morph transitions. The goal is to keep the user engaged while also reinforcing our team’s personality and strengths. Similarly, in the Notifications screen, I looked at layout clarity and how best to convey updates without overwhelming users.

In addition, I created the Login and Sign Up pages in Figma, establishing a clean and user-friendly entry point into the application. These screens set the tone for how users will first interact with JAICE, so I designed them with clarity and accessibility in mind, while still keeping them consistent with our overall branding direction.

• 

  Log In Screen

• 

  Sign Up Screen

• 

  About Screen: “Meet the Team”

Beyond design, I spent time refining how JAICE will present itself visually and conceptually. Elements like typography, branding, and overall flow are being aligned with our project philosophy: Clarity, Organization, and Empowerment for job seekers. While I continue to experiment with technical setups in personal projects, these exercises inform how I approach JAICE’s structure and styling, giving me a stronger sense of what will resonate with the end-users.

Overall, this week strengthened both the foundation of our workflow and the visual identity of JAICE. By combining backlog structure with design exploration, we’re setting the stage for a product that not only functions effectively but also delivers a professional, user-centered experience that job seekers will trust.

Week 2: Building a Foundation for JAICE

This week marked a major step forward in developing JAICE, our AI-powered job application tracker. Most of my focus was on establishing the visual identity and system architecture that will guide the rest of the project.

On the design side, I refined the style tile for JAICE. I finalized our headline, subheading, and body fonts (Baskerville Display PT and Poppins) and built out a complimentary color palette to ensure the platform feels both professional and modern. The photography and texture choices balance human-centered career imagery with tech-inspired network patterns, visually representing JAICE’s role as a bridge between users and AI-powered insights.

From a backend perspective, I created the first Entity Relationship Diagram (ERD). This defines how users, profiles, job applications, AI insights, and skills will connect within our PostgreSQL database. I also added proper data types to the schema to ensure the design can scale effectively. Alongside this, I drafted our folder hierarchy diagram, showing where frontend (Next.js) and backend (FastAPI) code will live, as well as documentation, deployment files, and scripts. This helps the team visualize where the real work will happen as development ramps up.

• 

  JAICE ERD with data types

• 

  Folder hierarchy flowchart

Finally, we improved our team workflow by creating a #work-updates channel in Discord. This will allow us to post async progress updates, reduce meeting overhead, and keep accountability high.

Altogether, this week was about laying a strong foundation. With design, database, and project structure in place, our team is ready to move into implementation and bring JAICE closer to reality.

My Portfolio Creation Journey

The Vision: A Digital Identity

From the beginning, I wanted my portfolio to stand out. I didn’t want my site to feel like just a resume online. Instead, I envisioned it as an interactive journey where visitors could explore my projects, learn about me, and get a sense of the passion I bring to tech and design.

I’ve always been drawn to bold and unique styles, so I leaned into a retro 8-bit digital theme with a black background and a bright lime green palette. It’s playful but professional, nostalgic yet modern, which is a style that mirrors my personality and creative approach.

Building Projects Into the Story

One of the most exciting parts was designing the Projects page. I didn’t want a standard grid of thumbnails. Instead, I experimented with a slot-machine style scroll for project cards. Each card reveals a snapshot of the project, and clicking the arrow expands into a detailed view, pulling in the README directly from GitHub.

Later, I added the ability to toggle between scroll view and grid vie, based on feedback gained., plus filters to help people explore projects by language or tags. This not only made the page more functional but also gave me a chance to play with transitions, animations, and usability improvements.

Telling My Story: The About Page

The About page became my favorite section. I expanded my biography to really share my journey. I added a quote that inspires me, and hen built out an interactive Skills section with tabs for “Developer” and “Designer.”

To make it engaging, I created a Swiper-powered carousel for my skill groups, complete with badges, links to documentation, and animated transitions. It transformed a basic list of tools into something immersive and fun to interact with.

What I Learned

This portfolio became more than just a project. It was a learning lab. Along the way, I:

• Pushed my React and Next.js skills further.
• Learned how to create reusable components that keep code clean.
• Experimented with animations and interactions that improved user experience.
• Balanced creativity with accessibility, making sure the design was fun but usable.

Most importantly, I learned that your portfolio should be more than just a showcase. It should tell your story.

The Road Ahead

Even though the site is live, I see it as a living project. I plan to keep iterating by adding new features, refining the design, and maybe even integrating an AI chatbot to help visitors navigate interactively.

This portfolio isn’t just a way to show what I can build. It’s a reminder of my journey as a developer/designer.

If you haven’t yet, check it out here: antoniolee.vercel.app

Introduction and Development Goals

Hello and welcome to my development blog! My name is Antonio Lee, and I’m a developer with a passion for building applications that merge creativity, usability, and technology. My background spans a wide range of experiences. From quality assurance and analytics at CarMax, to academic projects exploring artificial intelligence, data science, and UX/UI design. I’m currently studying Computer Science with a specialization in AI, continuously pushing myself to grow as a developer and problem solver.

Over the years, I’ve worked on many exciting projects, both personal and academic. Some highlights include:

• UniteMatch AI, an application that uses machine learning to optimize team compositions in Pokémon Unite.
• TaskMaster, a cross-platform task manager built with both CLI and GUI interfaces for organization and productivity.
• A wedding website coded from scratch using Next.js and Tailwind CSS, bringing a deeply personal event to life through design and functionality.

These projects, along with others you can find on my portfolio, antoniolee.vercel.app, reflect my commitment to learning and applying new technologies in practical ways.

Currently, I’m enrolled in Project and Portfolio V, where I’ll be working as part of a collaborative development team to design and build a fully functional application over the next several months. My primary focus will be frontend development and AI-driven features, but I’m also looking forward to diving into backend logic as our project grows.

This blog will serve as a weekly journal of my progress throughout the course. Each post will highlight a feature I’ve contributed to, or a challenge I faced and how I solved it. By the end of this journey, I hope to not only have a completed application but also a deeper understanding of the collaborative software development process.

Thank you for visiting and reading my first post. I’m excited to share my progress, insights, and lessons learned along the way!