Jeffrey A. Dettmann, Software Developer in Washington, DC, United States
Jeffrey A. Dettmann

Software Developer in Washington, DC, United States

Member since September 23, 2019
Jeff has broad experience using multiple technical stacks. Where he excels is data migration, ETL, and resolving difficult problems, like debugging unfamiliar applications and integrating systems designed to work standalone. While Jeff began working in technology in a university setting, he also has experience working in companies—both small and large.
Jeffrey is now available for hire




Washington, DC, United States



Preferred Environment

Linux Mint, Ubuntu, Git, Emacs

The most amazing...

...integration I've orchestrated involved two outside vendors, two internal departments, and three software development teams.


  • Back-end Developer

    2019 - 2019
    Nexhealth (via Toptal)
    • Transitioned from using config files on a client-hosted Python application to retrieving configuration from the server.
    • Ported the notification logic from Python to Ruby.
    • Added a duplication check/removal for synchronized data from the client system.
    Technologies: Ruby on Rails (RoR), Ruby, Python
  • Software Developer

    2010 - 2018
    Rosetta Stone
    • Converted content from 69 language learning activity models from two systems into a single system with even models; also built the server that hosted these new models.
    • Coordinated the transfer of a scheduling service from a vendor to in-house using a Shim server with no downtime and no changes to scheduling service client software.
    • Built a server in R for evaluating courseware efficacy.
    • Developed a performance monitoring system using Splunk.
    • Composed multiple scripts in Python for visualizing software usage statistics.
    • Built and maintained multiple microservices, included authorization, authentication, and content servers.
    • Created a migration tool in python that made authenticated REST calls to multiple services in order to build new profiles (with associated privileges) in a new application.
    • Developed multiple custom integrations with external/vendor systems.
    Technologies: MongoDB, CouchDB, MySQL, Python, R, Ruby on Rails (RoR), Ruby
  • Software Developer

    2007 - 2010
    Browser Media
    • Customized an open-source content management system for numerous clients.
    • Performed a batch conversion of hundreds of media files to Flash.
    • Coordinated the integration of a CMS with clients' software.
    • Implemented a PinnacleCart integration.
    • Built an S3 storage module for the CMS.
    Technologies: MySQL, Java, Ruby on Rails (RoR)
  • Senior Systems Analyst

    2003 - 2006
    University of Texas at Austin
    • Migrated legacy JCL generator code to a new system.
    • Constructed a tool to generate the SVG of a directed graph of JCL job queues.
    • Added a secure storage system to an internal storage tool.
    • Developed and maintained mainframe applications.
    • Built a utility to generate testing code for mainframe applications.
    Technologies: ADABAS, NATURAL, Java


  • Migration of a Scheduling System

    We were moving from a vendor's system of scheduling tutors to an internal tool; this system was used by applications in two separate branches of the organization.

    I built a reverse-proxy for the service and had all the client applications point to it instead of the vendor service. I then began converting the calls so that it would write to both scheduling services while reading from the vendor service. By implementing this process, I could synchronize the data in both scheduling services without any downtime.

    After the full data synchronization, I reconfigured the service to read from the service and convert the results to match the API of the vendor service. At this point, the development teams from both departments were able to integrate with the new service when they wanted while maintaining full uptime and data integrity.

  • Debugging the Degradation of a Service

    Our app users were experiencing a degraded experience, and I tracked down the cause: increased latency in the logging of a vendor's back-end service. Through historical data found in MongoDB, I discovered that before the degradation, logins took less than ten seconds on average, and afterward they took more than 20 seconds.

    Faced with the data, the vendor agreed that the problem was on their end and rebooted their servers, which temporarily addressed the issue. I set up a script to monitor the average login latency of the service, and thereby we noticed degradation before users started complaining and would then ask the vendor to reboot.

  • Data Visualization of Skipped Activities

    One of our apps presented users with activities designed to improve their performance on specific tasks. Users were allowed to skip an activity if they did not want to do it, and if they skipped three in a row, they left that set of exercises altogether.

    I developed a visualization of the skipping patterns that showed how the method of selecting the next activity exacerbated user frustration and increased the likelihood of skipping out of the section altogether. My work led to a correction in the algorithm that selected activities for users.

  • Reversible Data Migration

    Our organization was moving from a vendor tool and onto an in-house device with a different data model. I built a service that allowed users to convert their data in discrete units from one model to another. The service first ran heuristics on the existing data to show how cleanly the conversion would go, allowing owners of data to choose which parts of the conversion to do first.

    For the most part, the migration was seamless, but on occasion, the converted data would need to be manually validated and potentially altered to continue desired behavior. This process was completely reversible, so if the conversion went too far awry, the owners could go back to using the old system while they determined their best path forward.

  • SVG Representation of a Dependency Graph

    One of our tools ran batch jobs based on a set of conditions; e.g., the successful completion of a job could kick off another job, while its failure could trigger a different job altogether.

    The data model for these job networks was a collection of nodes and edges that were bound together by a common naming standard. So one record would say "A triggers B on success," and another record would say "B triggers C on success," and the system knew by the names A, B, and C that they were all part of the same job network.

    My task was to take these collections of nodes and edges and render a directed graph in SVG so that users could easily visualize the dependencies of their job network.


  • Frameworks

    Ruby on Rails (RoR), Scaled Agile Framework (SAFe), RStudio Shiny
  • Languages

    SQL, Ruby, Java, NATURAL, R, Bash, XSLT, XPath, XML, Python
  • Libraries/APIs

    Ruby on Rails API, Matplotlib, Pandas, FFmpeg, ImageMagick, PIL
  • Storage

    MySQL, ADABAS, Amazon S3 (AWS S3), CouchDB, MongoDB, JSON
  • Other

    Regular Expressions, RSync, Pdf2xml, Tesseract, Integration, Grep
  • Tools

    Emacs, Vim Text Editor, R Studio, RSpec, Rubocop, RabbitMQ, Git, Subversion (SVN), Perforce, Jenkins, Splunk
  • Paradigms

    Scrum, Agile, Test-driven Development (TDD), ETL Implementation & Design, ETL
  • Platforms

    Linux Mint, Ubuntu


  • PhD Degree in History
    1996 - 2002
    University of Texas, Austin - Austin, TX, USA
  • Bachelor of Arts Degree in Geography
    1986 - 1990
    University of Chicago - Chicago, IL, USA

To view more profiles

Join Toptal
Share it with others