Purpose & Goal

TeamWyrk is a platform that helps newcomers and entry-level tech professionals connect with insiders at tech companies without any transaction fees. It's currently in beta. It was on beta an has unfortunately entered an indefinite hiatus.

While I'm not the sole owner of TeamWyrk (shout-out to the TeamWyrk team!), I was thrilled to be a part of it for the time that I was involved.

Having mostly worked solo on projects before, joining a team of designers, PMs, and developers for a larger project was exciting! In my time there, I

• Implemented bug fixes and assigned JIRA tickets while getting familiar with the codebase
• Led the design and development of a soon-to-be-released in-app chat feature
• Ensured the feature is robust and meets design standards

I've enjoyed working with the talented TeamWyrkers and am excited to see this feature launch soon.

Some Features & Technical Details

Designing the in-house Chat feature

TeamWyrk connects "Insiders" (people working at specific companies) with "Requesters" (newer industry professionals looking to make connections). Initially, users connected via email in the alpha version.

With the team seeing the need for in-app chat, our designers crafted some sleek designs:

With our previous dev leads stepping back, me and two other new devs were tasked with implementing this feature while familiarizing ourselves with the codebase.

System Design from the ground up

In order to be aligned, I worked with out PMs to sketch out how this feature would interact with the Firestore backend (fullsize of image here):

The PM I was working with was not very technical, so he left it up to me to think about the collections we would need to add to our database. After some research, I mocked up this design and used it to explain it to the other devs:

Essentially, we would add two new collections: conversations and userConversationLogs. conversation documents contain an array of the actual messages, indicating when it was sent and by whom. On the other hand, userConversationLogs contains an array of conversations for each user, with metadata about the conversation (e.g. the last message), to easily display on the sidebar.

This way, it's easy and fast to look up all conversations about a user and display information about it's receiver. Here's a quick example of how in the sidebar, I use the conversation context, and the receiverID outlined in the database dseign above to get the receiver of the conversation with a simple useEffect:

useEffect(() => {
        async function fetchReceiver() {
            const receiverRef = doc(db, "user", conversation.receiverID);
            try {
                const docSnap = await getDoc(receiverRef);
                let data = null;
                if (docSnap.exists()) {
                    data = docSnap.data();
                    setReceiver(data);
                }
            } catch (error) {
                console.log("Error getting document:", error);
            } 
        }
        fetchReceiver();

    }, [conversation, isAuthenticated, user]);

Here's a test of me loading a conversation I had with my other account on the system. (note: the rendering of the actual conversation was assigned to another contributor of the TeamWyrk team):

Overall, this was a fun feature to help bring through fruition, and it was nice to see my backend skills transferred easily to a different context I wasn't as familiar with.

Lessons Learned

In this project, I quickly learned that the most challenging aspects of teamwork are often about communication and alignment, not just technical issues. Here are some takeaways:

• Technical:
  • Documentation: This was my first time ramping up on a large codebase written mostly by others. Consulting both external documentation (like Firebase) and internal team documentation was invaluable. Though documentation isn’t always fun to write, I’m now motivated to make it a core part of any project I work on.
• Project/Team Management:
  • JIRA: I never used JIRA much for personal projects, but I now see the need for tools like this and Agile sprints, especially for a distributed team.
  • Communicating with images and video: A picture really is worth a thousand words. My text explanations of database design weren’t clear, but when we used design diagrams, the conversations went much better.
  • Async working: With a distributed team, finding meeting times was tough, especially with most of us working full-time jobs. Tools like Loom were incredibly helpful for explaining ideas and creating a repository.
  • "A rising tide lifts all boats": After struggling to sync up, I considered just coding it all myself. However, I realized that documenting my workflow and ensuring others had a high-level understanding of the architecture was crucial. Empowering others to contribute is better than trying to ‘own’ the code.

Future Plans

TeamWyrk is currently on an indefinite hiatus due to circumstances beyond my control. Even so, I appreciated being part of this team.