Hello, I'm David đź‘‹

A passionate and self-taught Full Stack Developer with a background in engineering and education. After earning a Bachelor's degree in Engineering, I embarked on a decade-long journey teaching English at a Japanese private kindergarten in Tokyo. During this time, I discovered my enthusiasm for programming and web development, teaching myself the skills needed to solve real-world problems. My journey through diverse fields has equipped me with a blend of technical expertise, creative problem-solving, and effective communication skills. I'm driven by a desire to make impactful technological solutions and continuously seek opportunities to learn and grow in the realm of software development.

Projects

This is a selection of applications and systems I've developed:

Daycare Tracker
2018 - Present

A technology suite to simplify the management of daycare operations.

Chatison
2023 - Present

An efficient chatbot service based on OpenAI's API that provides tailored answers using user-defined context blocks and function calling.

Daycare Tracker

Daycare Tracker (DCT) is an integrated technology suite I developed to simplify the management of daycare operations at a private kindergarten in Tokyo. Born out of necessity and fueled by my passion for problem-solving, DCT is a custom-built solution designed to streamline various aspects of daycare management, including child attendance tracking, billing, and reporting.

The need for DCT emerged when the kindergarten transitioned from cash-based to automated bank transfer payments for daycare services. This shift required a more efficient, accurate, and automated approach to handle complex billing plans, daily attendance records, and monthly reporting. Recognizing the potential to significantly ease the staff's workload, enhance operational efficiency, and seize a valuable learning opportunity in software development, I started developing DCT.

Purpose and Impact

The primary goal of DCT was to automate and simplify daily tasks that were time-consuming and prone to errors. By customizing each component to the specific needs of the kindergarten, DCT has not only saved countless hours of manual work but also brought in accuracy and reliability, positively impacting both the staff's workflow and the parents' experience.

System Components

Daycare Tracker consists of the following four main components, each serving a unique function yet seamlessly integrated:

DCT-Nursery
swift

An iPad app for managing daily child attendance, reporting and billing.

DCT-Logger
swift

An iPod touch-based app for creating child portfolios effortlessly.

DCT-Terminal
react-native

A mobile app used at the entrance of the daycare for precise pickup time tracking.

DCT-Backend
nodejs

The backbone of the system, handling data, report generation, and integration with external APIs.

DCT-Nursery

Streamlining Childcare Management and Billing

In Use

2018 - Present

Role and Responsibilities

  • Sole Developer
  • Conceptualized and implemented a solution for efficient billing data management corresponding with the transition to a new payment system.

Technologies Used

  • Frontend: Xcode, Swift
  • Backend: Parse-Server, NodeJS (DCT-Backend)

Problem Solved

  • Transitioned from cash-based payment to an automated bank transfer system, necessitating a reliable method to generate monthly and anual billing data and reporting.
  • Managed complexities of different billing plans for up to 70 children daily.

Solution

Developed an iOS app with a user-friendly interface for easy data entry and management with the following features:

  • A calendar-based main screen for daily group attendance and billing plan overview.
  • Day view for detailed attendance, including pick-up times and billing plans.
  • Efficient member addition with name filtering or QR code scanning.
  • Backend integration for data processing and report generation (DCT-Backend).

Impact

  • Time-saving: Estimated to save at least one hour daily and significant time monthly and annually for report generation.
  • Accuracy: Substantially reduced billing errors over 5 years of use.
  • Customized Solution: Surpassed off-the-shelf alternatives in meeting the unique billing structure of the school.
  • Extended Application: Successfully implemented in a partner school with similar positive feedback.

Challenges and Learning

  • Learned Xcode, Swift and JavaScript (NodeJS).
  • Overcame initial challenges in understanding and implementing nested loops and displaying this data in collection views nested in table cells.
  • Gained knowledge in asynchronous programming and integration with external APIs like Dropbox.
  • Learned the importance of user-centric design through observing teacher interactions with DCTNurserythe app.

Visuals

Calendar screen, listing the type of school day, the duration of school, the daycare groups and the number of attendees for each group.
Group session overview screen, displaying details for this group session and the list of attendees and their attendance data along with options to edit, delete or generate a report for this group session.
A quick overview of the plans used in this group session.
Group session entry screen. This is where children get selected either by searching them from the list on the left or by scanning their QR code. The list on the right contains the attendees of this group which can quickly be edited or removed. After editing the list of attendees, it needs to be saved. This approach was chosen to ensure data integrity without saving each changed entry, which would disrupt the workflow of the user.
Selecting a child reveals the list of plans to select from. Multiple plans can be selected.
Report creation screen. After all data for a month is collected, the option to create a report for this month and group is made available in this list. This will create the monthly report along with billing statements and billing data to pass to the payment provider.
An example of the daily report generated as a PDF file.
Page 2 of the daily report generated as a PDF file.

DCT-Logger

Simplifying Child Portfolio Creation

In Use

2019 - Present

Role and Responsibilities

  • Sole Developer
  • Designed and implemented an app to streamline the creation of child portfolios for kindergarten teachers.

Technologies Used

  • Xcode, Swift for app development.
  • Integrated with DCT-Backend for data handling and document creation.
  • Utilized S3 and Dropbox APIs for image storage and document synchronization.

Problem Solved

  • Addressed the time-consuming task of manually creating multiple child portfolios in a specific format.
  • Replaced a cumbersome process involving transferring images to a computer, formatting in Word, and managing files.

Solution

DCT-Logger, an iOS app enabling teachers to create portfolios directly from iPod Touch devices with the following features:

  • Easy posting of images with date and text, automatically formatted and saved as a Word document.
  • Efficient tracking of portfolio creation for each child to ensure equitable attention.
  • A feed to view all portfolios in chronological order, enhancing organizational efficiency.

Impact

  • Significantly reduced the time and effort involved in portfolio creation.
  • Eliminated layout inconsistencies and formatting challenges, ensuring uniformity in portfolios.
  • Enabled teachers to focus on capturing quality content rather than managing technical aspects.

Challenges and Learning

  • Addressed challenges in secure image handling and storage scalability using S3 with signed URLs.
  • Adapted to changes in Dropbox API, learning the importance of staying updated with external APIs.

Visuals

Main screen to quickly create a portfolio entry by writing a text, selecting a child and selecting the teacher who makes the entry (this selection remains the default). The date of the portfolio entry is automatically applied from the image meta data but can be changed manually. In the top right are navigation items to reveal the portfolio feed and the settings screen. After saving, the portfolio is added to the feed and DCT-Backend creates a docx file of the portfolio and saves it to DropBox.
Child selection screen. The list can be quickly filtered by starting to type in the search field at the top.
Staff selection screen. The list can be quickly filtered by starting to type in the search field at the top.
Simple setting screen which is usually not used by staff.
Feed screen to view portfolio entries. The images are loaded with an S3 signed URL just before they come into view. The feed supports endless scroll by loading more entries before the end of the list is reached.

DCT-Terminal

Automated Child Pickup Tracking System

In Use

2023-09 - Present

Role and Responsibilities

  • Sole Developer
  • Tasked with developing a solution for accurately tracking child pickup times and managing additional fees.

Technologies Used

  • Developed using React Native with Expo and EAS build.
  • Integrated with DCT-Backend for data management.
  • QR Code scanning and offline data storage functionality.

Problem Solved

  • Addressed the challenge of accurately tracking child pickup times, particularly for late pickups with additional fees.
  • Replaced manual timekeeping and decision-making by teachers, reducing workload and potential disputes.

Solution

DCT-Terminal, a mobile app designed for ease of use, energy efficiency, and offline functionality with the following features:

  • Simple, intuitive interface with QR code scanning for instant pickup confirmation.
  • Offline functionality to record timestamps in areas without internet connectivity.
  • Local data caching with synchronization capabilities to the backend.
  • Teacher discretion in applying additional fees, with timestamps as a reliable reference.
  • User-friendly and visually appealing design, suitable for a preschool environment.

Impact

  • Eliminated the need for teachers to manually track pickup times, significantly reducing their end-of-day workload.
  • Provided a reliable and dispute-free system for applying additional fees.
  • Improved the overall efficiency of the daily reporting process, integrating pickup times seamlessly.

Challenges and Learning

  • Balancing user-friendliness with technical complexity, choosing QR codes over NFC for practicality.
  • Developed skills in React Native, focusing on user interface design and offline functionality.
  • Addressed security concerns in a customer-facing app, ensuring device and data protection.
  • Learned to effectively use animations for an engaging user experience.

Visuals

An iPod touch with DCT-Terminal running at the entrance of the daycare. Initially it was planned to use the front facing camera for scanning, however, after testing and observing how people interacted with the app, it was decided to use the rear facing camera instead to offer a fixed position as a guide to place the QR cards.
The main screen of the app. The app is running in guided access mode to keep the screen on and prevent undesired interactions with the device. Since the camera and screen are always on, a mostly black interface was used to save energy.
Loading indicator after a card is scanned. The app will first attempt to save the timestamp to DCT-Backend and if this fails it will fall back to saving the timestamp on the device for later synchronization.
Confirmation of successful scan (and timestamp creation).
Alternative scan screen which is used if the user has trouble placing their card. This screen offers a visual feedback of the camera view.
A child can be manually selected from a list in case the parent forgot their card with the QR code.
A pin code is required to access the settings screen.
In the settings screen, the teacher can see the number of timestamps that were stored on the device and synchronize them with DCT-Backend after which the offline data is cleared and the number is reset to 0. Turning “Fastlane” on means that the camera is always on and QR codes can be scanned immediately. If this is turned off, the main screen changes and the user first has to tap a start button which reveals the alternative scan screen and activates the camera until a code is scanned or until it times out after one minute and returns to the main screen. This can be used to conserve energy.

DCT-Backend

Centralized Data Management and Report Generation

In Use

2018 - Present

Role and Responsibilities

  • Sole Developer
  • Designed and implemented a backend system to integrate and automate various school management processes.

Technologies Used

  • Backend: Parse-Server, NodeJS (JavaScript), MongoDB Atlas
  • Deployment and Security: Docker Compose, Traefik Reverse Proxy, SSL Certificates
  • Integration: Dropbox API, AWS S3 (later Backblaze B2), various document generation packages (pdfkit, docx, pizzip, docxtemplater, libreoffice-convert)

Problem Solved

  • Facilitated the transition from cash-based payments to bank transfers by automating billing and report generation.
  • Managed complex data from multiple sources (attendance, billing, child portfolios) for streamlined operations.

Solution

Built a robust backend infrastructure capable of handling diverse data types and generating various reports with the following features:

  • Centralized data repository including child details, class divisions, attendance, and billing plans.
  • Automated creation of daily reports, monthly billing statements, and annual compliance reports.
  • Secure image handling for child portfolios with authorization checks and signed URLs.
  • Efficient data synchronization and accessibility through Dropbox for staff and sister school.

Impact

  • Significant reduction in manual data processing time, estimated to save countless hours annually.
  • Near elimination of errors in billing and reporting, ensuring accuracy and compliance.
  • Customization and flexibility to meet unique operational needs of the school.

Challenges and Learning

  • Early-stage decisions on technology selection balancing speed of development, functionality and maintainability.
  • Learned NodeJS, including working with asynchronous functions and external APIs.
  • Development of a comprehensive understanding of data security and privacy.
  • Gained insights into translating real-world processes into efficient programming solutions.

Chatison

Chatison is a prototype of a chatbot service leveraging OpenAI's API. Its primary focus is to provide highly relevant answers on user-defined topics while minimizing token usage.

This efficiency is achieved by allowing users to define clearly labeled context blocks. When a new chat thread is initiated, the assistant receives a list of these context blocks, complete with their IDs and labels, along with minimal context about the chat's objective and instructions. If the assistant encounters a query that cannot be addressed with the provided minimal context, it employs function calling to request additional information on one or more relevant topics from the context block list. The system then supplies this extra context to the assistant, enabling it to formulate a more informed response to the user.

This approach ensures that only the necessary number of tokens are used to deliver relevant answers across a potentially wide range of user-defined topics.

Lessons Learned

Currently, Chatison uses the OpenAI Assistants API. While Assistants allow for fast implementation of a functional chatbot, they also present limitations in controlling token usage and context window size. I've learned that an assistant utilizes all tokens in a thread for each interaction, leading to a rapid increase in token usage as the maximum context window size is approached. This, while beneficial for response quality, poses a challenge in terms of token efficiency. Consequently, my assessment is that the Assistants API, in its current form, is not ideally suited for a public-facing chatbot service. For such a service, having precise control over token usage and context window size is essential to ensure secure and efficient operation.

Future Improvements

Thank you for stopping by đź‘‹