Summer at PROS

I was a Product Development Intern on the Revenue Management team at PROS in the Summer of 2020. I worked on the frontend of a feature while also implementing a method for a another larger feature on the backend.

I worked through the entire product development process for the frontend with the guidance of my mentor who was working on the backend of this feature.

View the Revenue Management product

Timeline: June 2020 - August 2020
Role: Product Development Intern
Tools: React, Redux, Node.js, Jest, Cucumber, Java, Spring Boot, Gradle

Result

I successfully implemented a frontend for the ticket price optimization feature fully integrated with the backend. It will be included in the next quarterly release of the new product UI to clients. The backend method I implemented will be used as part of a larger view and will be released in the future.

I made a sizable contribution to the development of the new UI with the implementation of my feature. This was the main project in the team, and will continue as all features on the legacy UI are being added and improved upon on the new UI.

Product Requirements

Revenue Management (RM) is a price optimization software for airlines. It allows the client to predict passenger demand using market trends and seasonal patterns among other factors. This helps the airline to make decisions that maximize their revenue for every seat in their flights.

The team consisted of about 40 people, and the majority were working on implemented a new UI for the product. The existing product was running in Internet Explorer, and had frontend created from Java. With an increase in the number of users and impact of the product, combined with the rise of popularity with many modern browsers, the team has been working on implementing all features in a React frontend while refining the Java backend.

At the start of implementing my features, I had many meetings with the UX team and the Product Manager to clarify the requirements listed on the Jira Story of the feature. Using the feedback and clarifications, I was able to split the story into more focused and manageable subtasks.

Code Design

Before starting to code, I used the feedback from the requirements stage to come up with a code design for the feature. This involved the components and functions I planned to create, how certain requirements were going to be implemented, and the structure of the feature frontend in general.

I had design reviews with my mentors and other members of the team to verify my approach. After that, I could move on to the next stage.

Implementation

With that done and having explored the codebase, I implemented the feature. Since this was quite a large feature, I had a set plan to implement each subtask. I went over my progress and sprint predictions during the daily scrum, and rearranged tasks as necessary during sprint planning.

I used React, Redux, Node.js, and some internal tools to implement the feature. I learnt a lot about Redux and some other React libraries such as lodash for making concise and efficient production code.

I wrote JUnit tests for code coverage, and monitored Jenkins while making pull requests to merge into the master code. Code reviews from other team members while merging was really insightful to help me improve my code quality.

Challenges and introducing new patterns

One of the main challenges in my project came with the UI requirements introduced for improved interactions. The save button was supposed to make a PUT and POST request with the new UI. With no previous implementation of this interaction, there was no existing pattern to reference. I recognized that this problem was similar to task synchronization, and proposed a semaphore-like solution to handle it.

My original code was quite clunky, as there were many parts I had to implement to handle the different conditions. By meeting with team members experienced with implementing new patterns, I was able to get my code cleaned up and merged.

In the later part of implementation, I synced up with PM, UX, and my mentor to ensure that it integrates as expected with the backend. With a week left of my internship, I finished implementing the feature.

Review and Testing

During the implementation phase, I met with the QA tester in charge of the feature to clarify any remaining requirements and come up with a timeline for testing. With my feature done, I handed it off for testing for any unforseen behavior before it is added to release.

In the last few weeks, I also worked on a method for another future feature in Java Spring Boot. I wrote BDD tests in Cucumber for code coverage to ensure that the backend works as it should.

Conclusion

I learned a lot during this internship, especially about writing production code and working in a software development team. Although the internship was remote, my mentors were very helpful and made themselves very available.

I'm excited that the feature will be released for clients as part of the new UI. With this internship, I've learned to adjust to new codebases quickly and gained a lot more experience with React and libraries like Redux.