Designed, created, and developed an admin application for a local bookstore. The main functions of the application included: a method to process new inventory via invoices from vendors, search functionality within that inventory, and a point of sale solution to handle orders through an integration with Square. I worked closely with the store owner to gather and prioritize requirements, providing regular demos of features as they were developed. The bookstore is slated to open in late 2024.

The application was a Next.js app written in Typescript, utilizing React components on the frontend and Next.js server components along with APIs on the backend. The server code connected to a Postgres database using Prisma as the ORM. Custom components were written and demoed with Storybook. CI was handled through GitHub actions using Jest style tests, and Playwright end to end tests covered the main flows. The application was deployed and hosted via AWS.

The source code for the application can be found at: https://github.com/dylants/bookstore

Senior Engineer at an early stage startup. Responsible for leading projects and mentoring other engineers. The larger scoped projects required up front technical design, a breakdown of work into tickets, regular updates, and taking point on development. Worked closely with product and design to quickly build prototypes. Regularly triaged support issues to identify root cause and resolve problems.

The product was an AI based solution, using data sourced from the customer to supply context to an LLM, which could then be queried through chat or pre-defined prompts. The frontend was built with React and Next.js, using Tailwind driven custom components. The backend was built in Python, using FastAPI to host REST endpoints and Google Firestore as the database. An earlier iteration of the product was a Node.js web application written in Typescript with Apollo GraphQL as the API layer. A mix of Jest and Playwright were used for testing, and Storybook to showcase components.

Established a team process for how work was done. Conducted planning meetings to break down work and build out a reliable roadmap. Communicated regularly with stakeholders to create transparency in our process and alignment on the team. Instituted team demo sessions to share knowledge. Added weekly team commitments, and reflected and iterated as a team during retro.

Paired with engineers to complete feature work. Held educational sessions with more junior engineers and explored necessary changes to the systems and architecture with more senior engineers. Encouraged feedback and provided regular feedback during weekly 1-1s. Conducted quarterly reviews providing guidance on areas of success and areas of growth across core competencies.

Redesigned the engineering hiring process. Introduced Coderpad as a technical screening tool and developed questions along with the rubric. Defined a remote onboarding process for new hires which included guidance on the manager's initial meeting, a cadence for regular learnings in the first two weeks, cross team introductions with other engineering teams, and feedback on the approach to improve.

The main application was written in Rails with a React frontend. A custom CMS solution was built utilizing a common set of React components which users could personalize within a custom admin interface. Some solutions required third party technologies, such as offsite advertising, which needed an up-to-date replica of all products in Google Merchant Center.

Developed both the backend APIs and frontend UI for a next-gen customer experience. Planned out features, mentored junior engineers, and worked with senior leadership to establish consistent and reliable development patterns going forward.

The application consisted of a MySql database, a Node.js API layer, and a React UI. The backend layer utilized Sequelize for modeling of the data and Express for API management. React and Redux were used to build out the frontend and handle state management and communication with the APIs.

Led the front end team in building out features in short iterations. This included working closely with product and design to decide on features to develop, then communicating that work out to the team while discussing impacts with the broader organization. Held daily standups, weekly planning meetings, and retrospectives to help gain insight into how we can improve the process.

Responsible for guiding the front end architecture along with mentoring junior developers. I regularly paired with engineers to assist in development, and could often be found drawing on a whiteboard to help explain difficult pieces of the system or how the team should move forward with a specific implementation. I worked with the operations team to build and deploy our applications in CI and in production, while also working alongside test teams to design our test strategy.

The UI applications were web based, using React, Redux, and Webpack on the client side and Node with Express on the server side. Node modules were developed to help share code across applications, which included a common set of UI components to retain consistency in the views.

As a founding engineer, led both the team and the development of the user interface for the company. Responsible for hiring new engineers, along with mentoring and leading the team. Led daily standups and retrospectives. Responsible for working with product and business teams to break down customer requirements into work items for the team.

The web technology was a mix of React/Redux, along with React Native in native app development. Node.js was used to power the server side of the UI, utilizing Express for APIs and Mongo for storage. Earlier iterations used Angular, and in the native device case, a combination of Ionic and Angular.

Assisted the developer operations team on deployment of the Node.js applications, as well as production support for applications. Helped build documentation and training for customer sessions.

Co-organizer, mentor, and frequent presenter of Austin NodeSchool. Helped build the Austin NodeSchool presence using the available open source community tools and encouraged others to help with this effort. Presented multiple workshops at events and helped answer questions outside the hosted events. More information can be found at Austin NodeSchool.

Volunteer for the MakerSquare mentor program. MakerSquare provides a three-month course for students who are interested in transitioning to a software engineering career. I often was paired with a student for me to mentor outside of class. I met with each of these students on a weekly basis and, during these meetings, helped with course material, answered questions, reviewed the student's resume, and provided advice about the industry.

Lead engineer for small experimental Labs team. Developed APIs useful in prototyping a mobile app experience. The APIs were developed in Node.js, using Express, and utilized Mongo as the backend database. Passport security was integrated to allow user profiles in the mobile app. Developed an Apple push notification service for the app. Setup an internal npm registry for Node.js packages, and helped developer operations design automation to deploy Node.js to production.

Developed an e-commerce marketplace platform to provide vendors an ability to sell to the general public. The APIs were developed in Java/Spring, and utilized Spring Security. Designed and developed an admin interface to the system using Backbone.js, and used Node.js to both serve up the UI and test the backend APIs. Setup a Jenkins continuous integration server to run nightly builds and deploy to an AWS EC2 environment.

Built and maintained third party JavaScript web applications which merchants could use to interact with the PayPal Identity offering, using mostly Backbone as a framework, Dust as a templating engine, and RequireJS to manage dependencies. Spring REST and Node.js (depending on the application) were used on the backend to manage sending data needed to the client (browser).

Led development and architecture of a major redesign of the legacy platform to an open source Spring/JAX-RS/OSGi based solution. The update included adoption of a JavaScript MVW style framework for the frontend.

Continually involved in design, architecture, and planning of future work by aligning with the business, reaching out to external teams, and resource planning for FY2012/13 deliverables.

PayPal and eBay were part of the same company during this time.

Senior developer on a web application infrastructure framework (code named "Sparta"). Lead technical developer on PayPal's Digital Goods Express Checkout application, the first PayPal web flow to use “Remember Me” authentication.

Developed, led, and maintained code used by PayPal to host Java based applications running the PayPal website. Architected and developed multiple Java based projects glued together with Maven, utilizing Spring for core configuration and web flow. Designed and implemented Eclipse based plugins used by developers to build applications and add individual web pages to existing projects. Led education sessions across the company on how to use Java, Spring, Maven, Eclipse, and Sparta based applications.

Created, designed, and implemented a Java based automation framework used by teams across PayPal. Led an effort to migrate testing to this Java based framework, gave presentations on its need and benefits to executive level management while leading educational sessions across the company.

Acquired a proficiency in Web Services policy set framework and administrative console, in addition to Web Services Security internals and caching solutions. Designed and implemented many features in Web Services, including schema definitions, working with JAXB generated objects, policy interactions, security role definitions, and multiple admin tasks.

Developed Web Services Security functions. This required an understanding of internal caching mechanisms and an expansion upon those using MBean and JDBC/Database solutions.

Began career manually testing the web interface of WebSphere Console, and found that moving the test team to a GUI automation solution would greatly increase efficiency. Led a team to develop a framework using Rational Functional Tester which tested the WebSphere Console. As more WebSphere Console FVT teams chose to adopt it, the framework was broadened to support the multiple users. This work led to patent submissions.

Led an RFT focused GUI Automation Community consisting of many members across IBM worldwide. Created and led a WebSphere Console automation team using the GUI automation framework I designed and developed the previous year.

Designed automation harnesses to test Web Services Policy Set features, Jython admin commands, Web Services Security, and general service and client Web Services application.

Worked as a co-op while attending college. Performed Functional Verification Test (FVT) for a Network Authentication Service, IBM's Kerberos security product. Performed System Verification Test (SVT) for DCE and Network Authentication Service. Became technical team lead for the WebSphere FVT automation project using a GUI automation tool named Rational XDE/Robot.