# frozen_string_literal: true

module Healthcare
  module AI
    # Responsible for building a structured
    # patient context for inference pipelines.
    #
    # Single Responsibility: knows only how
    # to assemble a PatientContext value object.
    class PatientContextBuilder
      def initialize(patient:, records:, normalizer:)
        @patient    = patient
        @records    = records
        @normalizer = normalizer
      end

      # @return [PatientContext]
      def build
        PatientContext.new(
          id:          @patient.id,
          age:         @patient.age,
          diagnoses:   normalize_diagnoses,
          vitals:      latest_vitals,
          risk_score:  compute_risk
        )
      end

      private

      def normalize_diagnoses
        @records
          .flat_map(&:diagnoses)
          .map { |d| @normalizer.call(d) }
          .uniq
      end

      def latest_vitals
        @records
          .filter_map(&:vitals)
          .max_by(&:recorded_at)
      end

      def compute_risk
        RiskScorer.new(@patient, @records).score
      end
    end
  end
end

module Healthcare
  module AI
    # Open/Closed: extend scoring by subclassing,
    # not by modifying existing scorer logic.
    class RiskScorer
      WEIGHTS = {
        age:         0.3,
        comorbidity: 0.5,
        vitals:      0.2
      }.freeze

      def initialize(patient, records)
        @patient = patient
        @records = records
      end

      # @return [Float] 0.0..1.0
      def score
        WEIGHTS.sum do |factor, weight|
          send(:"#{factor}_score") * weight
        end.clamp(0.0, 1.0)
      end

      private

      def age_score
        (@patient.age / 100.0).clamp(0.0, 1.0)
      end

      def comorbidity_score
        count = @records
                  .flat_map(&:diagnoses)
                  .size
        (count / 10.0).clamp(0.0, 1.0)
      end

      def vitals_score
        vitals = @records
                   .filter_map(&:vitals)
                   .last
        return 0.0 unless vitals

        vitals.abnormality_index
      end
    end
  end
end
# frozen_string_literal: true

module Healthcare
  module AI
    # Responsible for building a structured
    # patient context for inference pipelines.
    #
    # Single Responsibility: knows only how
    # to assemble a PatientContext value object.
    class PatientContextBuilder
      def initialize(patient:, records:, normalizer:)
        @patient    = patient
        @records    = records
        @normalizer = normalizer
      end

      # @return [PatientContext]
      def build
        PatientContext.new(
          id:          @patient.id,
          age:         @patient.age,
          diagnoses:   normalize_diagnoses,
          vitals:      latest_vitals,
          risk_score:  compute_risk
        )
      end

      private

      def normalize_diagnoses
        @records
          .flat_map(&:diagnoses)
          .map { |d| @normalizer.call(d) }
          .uniq
      end

      def latest_vitals
        @records
          .filter_map(&:vitals)
          .max_by(&:recorded_at)
      end

      def compute_risk
        RiskScorer.new(@patient, @records).score
      end
    end
  end
end

module Healthcare
  module AI
    # Open/Closed: extend scoring by subclassing,
    # not by modifying existing scorer logic.
    class RiskScorer
      WEIGHTS = {
        age:         0.3,
        comorbidity: 0.5,
        vitals:      0.2
      }.freeze

      def initialize(patient, records)
        @patient = patient
        @records = records
      end

      # @return [Float] 0.0..1.0
      def score
        WEIGHTS.sum do |factor, weight|
          send(:"#{factor}_score") * weight
        end.clamp(0.0, 1.0)
      end

      private

      def age_score
        (@patient.age / 100.0).clamp(0.0, 1.0)
      end

      def comorbidity_score
        count = @records
                  .flat_map(&:diagnoses)
                  .size
        (count / 10.0).clamp(0.0, 1.0)
      end

      def vitals_score
        vitals = @records
                   .filter_map(&:vitals)
                   .last
        return 0.0 unless vitals

        vitals.abnormality_index
      end
    end
  end
end
# frozen_string_literal: true

module Healthcare
  module AI
    # Responsible for building a structured
    # patient context for inference pipelines.
    #
    # Single Responsibility: knows only how
    # to assemble a PatientContext value object.
    class PatientContextBuilder
      def initialize(patient:, records:, normalizer:)
        @patient    = patient
        @records    = records
        @normalizer = normalizer
      end

      # @return [PatientContext]
      def build
        PatientContext.new(
          id:          @patient.id,
          age:         @patient.age,
          diagnoses:   normalize_diagnoses,
          vitals:      latest_vitals,
          risk_score:  compute_risk
        )
      end

      private

      def normalize_diagnoses
        @records
          .flat_map(&:diagnoses)
          .map { |d| @normalizer.call(d) }
          .uniq
      end

      def latest_vitals
        @records
          .filter_map(&:vitals)
          .max_by(&:recorded_at)
      end

      def compute_risk
        RiskScorer.new(@patient, @records).score
      end
    end
  end
end

module Healthcare
  module AI
    # Open/Closed: extend scoring by subclassing,
    # not by modifying existing scorer logic.
    class RiskScorer
      WEIGHTS = {
        age:         0.3,
        comorbidity: 0.5,
        vitals:      0.2
      }.freeze

      def initialize(patient, records)
        @patient = patient
        @records = records
      end

      # @return [Float] 0.0..1.0
      def score
        WEIGHTS.sum do |factor, weight|
          send(:"#{factor}_score") * weight
        end.clamp(0.0, 1.0)
      end

      private

      def age_score
        (@patient.age / 100.0).clamp(0.0, 1.0)
      end

      def comorbidity_score
        count = @records
                  .flat_map(&:diagnoses)
                  .size
        (count / 10.0).clamp(0.0, 1.0)
      end

      def vitals_score
        vitals = @records
                   .filter_map(&:vitals)
                   .last
        return 0.0 unless vitals

        vitals.abnormality_index
      end
    end
  end
end

# frozen_string_literal: true

module Healthcare
  module AI
    # Liskov Substitution: any Notifier can be
    # swapped without altering calling code.
    module Notifier
      NotificationError = Class.new(StandardError)

      # @param context [PatientContext]
      # @param event   [Symbol]
      # @return [void]
      def notify(context:, event:)
        raise NotImplementedError,
              "#{self.class} must implement #notify"
      end
    end

    class SlackNotifier
      include Notifier

      def initialize(client:, channel:)
        @client  = client
        @channel = channel
      end

      def notify(context:, event:)
        @client.post(
          channel: @channel,
          text:    format_message(context, event)
        )
      rescue => e
        raise NotificationError, e.message
      end

      private

      def format_message(ctx, event)
        "[#{event.upcase}] Patient #{ctx.id} " \
        "— Risk: #{(ctx.risk_score * 100).round}%"
      end
    end

    class AuditLogNotifier
      include Notifier

      def initialize(logger:)
        @logger = logger
      end

      def notify(context:, event:)
        @logger.info(
          event:      event,
          patient_id: context.id,
          risk_score: context.risk_score,
          timestamp:  Time.now.utc.iso8601
        )
      end
    end

    # Interface Segregation: pipeline steps
    # depend only on #call — nothing else.
    class InferencePipeline
      def initialize(steps:)
        @steps = steps
      end

      # @param context [PatientContext]
      # @return [PatientContext]
      def run(context)
        @steps.reduce(context) do |ctx, step|
          step.call(ctx)
        end
      end
    end
  end
end
# frozen_string_literal: true

module Healthcare
  module AI
    # Liskov Substitution: any Notifier can be
    # swapped without altering calling code.
    module Notifier
      NotificationError = Class.new(StandardError)

      # @param context [PatientContext]
      # @param event   [Symbol]
      # @return [void]
      def notify(context:, event:)
        raise NotImplementedError,
              "#{self.class} must implement #notify"
      end
    end

    class SlackNotifier
      include Notifier

      def initialize(client:, channel:)
        @client  = client
        @channel = channel
      end

      def notify(context:, event:)
        @client.post(
          channel: @channel,
          text:    format_message(context, event)
        )
      rescue => e
        raise NotificationError, e.message
      end

      private

      def format_message(ctx, event)
        "[#{event.upcase}] Patient #{ctx.id} " \
        "— Risk: #{(ctx.risk_score * 100).round}%"
      end
    end

    class AuditLogNotifier
      include Notifier

      def initialize(logger:)
        @logger = logger
      end

      def notify(context:, event:)
        @logger.info(
          event:      event,
          patient_id: context.id,
          risk_score: context.risk_score,
          timestamp:  Time.now.utc.iso8601
        )
      end
    end

    # Interface Segregation: pipeline steps
    # depend only on #call — nothing else.
    class InferencePipeline
      def initialize(steps:)
        @steps = steps
      end

      # @param context [PatientContext]
      # @return [PatientContext]
      def run(context)
        @steps.reduce(context) do |ctx, step|
          step.call(ctx)
        end
      end
    end
  end
end
# frozen_string_literal: true

module Healthcare
  module AI
    # Liskov Substitution: any Notifier can be
    # swapped without altering calling code.
    module Notifier
      NotificationError = Class.new(StandardError)

      # @param context [PatientContext]
      # @param event   [Symbol]
      # @return [void]
      def notify(context:, event:)
        raise NotImplementedError,
              "#{self.class} must implement #notify"
      end
    end

    class SlackNotifier
      include Notifier

      def initialize(client:, channel:)
        @client  = client
        @channel = channel
      end

      def notify(context:, event:)
        @client.post(
          channel: @channel,
          text:    format_message(context, event)
        )
      rescue => e
        raise NotificationError, e.message
      end

      private

      def format_message(ctx, event)
        "[#{event.upcase}] Patient #{ctx.id} " \
        "— Risk: #{(ctx.risk_score * 100).round}%"
      end
    end

    class AuditLogNotifier
      include Notifier

      def initialize(logger:)
        @logger = logger
      end

      def notify(context:, event:)
        @logger.info(
          event:      event,
          patient_id: context.id,
          risk_score: context.risk_score,
          timestamp:  Time.now.utc.iso8601
        )
      end
    end

    # Interface Segregation: pipeline steps
    # depend only on #call — nothing else.
    class InferencePipeline
      def initialize(steps:)
        @steps = steps
      end

      # @param context [PatientContext]
      # @return [PatientContext]
      def run(context)
        @steps.reduce(context) do |ctx, step|
          step.call(ctx)
        end
      end
    end
  end
end

# frozen_string_literal: true

module Healthcare
  module AI
    # Dependency Inversion: high-level orchestrator
    # depends on abstractions, not concrete classes.
    class PatientAnalysisService
      def initialize(
        builder:,
        pipeline:,
        notifiers: []
      )
        @builder   = builder
        @pipeline  = pipeline
        @notifiers = notifiers
      end

      # @param patient [Patient]
      # @param records [Array<MedicalRecord>]
      # @return [AnalysisResult]
      def analyze(patient:, records:)
        context = @builder.build(
          patient: patient,
          records: records
        )

        result = @pipeline.run(context)

        broadcast(:analysis_complete, result)

        AnalysisResult.new(
          context:    result,
          flagged:    result.risk_score > 0.75,
          created_at: Time.now.utc
        )
      rescue => e
        broadcast(:analysis_failed, nil)
        raise
      end

      private

      def broadcast(event, context)
        @notifiers.each do |notifier|
          notifier.notify(
            context: context,
            event:   event
          )
        rescue Notifier::NotificationError => e
          Rails.logger.warn(
            "Notifier failed: #{e.message}"
          )
        end
      end
    end

    # Value object — immutable analysis result.
    AnalysisResult = Data.define(
      :context,
      :flagged,
      :created_at
    )

    # Value object — immutable patient snapshot.
    PatientContext = Data.define(
      :id,
      :age,
      :diagnoses,
      :vitals,
      :risk_score
    )
  end
end

# Wiring (e.g. in a Rails initializer)
#
# Healthcare::AI::PatientAnalysisService.new(
#   builder:   PatientContextBuilder.new(...),
#   pipeline:  InferencePipeline.new(steps: [...]),
#   notifiers: [
#     SlackNotifier.new(client: ..., channel: "#alerts"),
#     AuditLogNotifier.new(logger: Rails.logger)
#   ]
# )
# frozen_string_literal: true

module Healthcare
  module AI
    # Dependency Inversion: high-level orchestrator
    # depends on abstractions, not concrete classes.
    class PatientAnalysisService
      def initialize(
        builder:,
        pipeline:,
        notifiers: []
      )
        @builder   = builder
        @pipeline  = pipeline
        @notifiers = notifiers
      end

      # @param patient [Patient]
      # @param records [Array<MedicalRecord>]
      # @return [AnalysisResult]
      def analyze(patient:, records:)
        context = @builder.build(
          patient: patient,
          records: records
        )

        result = @pipeline.run(context)

        broadcast(:analysis_complete, result)

        AnalysisResult.new(
          context:    result,
          flagged:    result.risk_score > 0.75,
          created_at: Time.now.utc
        )
      rescue => e
        broadcast(:analysis_failed, nil)
        raise
      end

      private

      def broadcast(event, context)
        @notifiers.each do |notifier|
          notifier.notify(
            context: context,
            event:   event
          )
        rescue Notifier::NotificationError => e
          Rails.logger.warn(
            "Notifier failed: #{e.message}"
          )
        end
      end
    end

    # Value object — immutable analysis result.
    AnalysisResult = Data.define(
      :context,
      :flagged,
      :created_at
    )

    # Value object — immutable patient snapshot.
    PatientContext = Data.define(
      :id,
      :age,
      :diagnoses,
      :vitals,
      :risk_score
    )
  end
end

# Wiring (e.g. in a Rails initializer)
#
# Healthcare::AI::PatientAnalysisService.new(
#   builder:   PatientContextBuilder.new(...),
#   pipeline:  InferencePipeline.new(steps: [...]),
#   notifiers: [
#     SlackNotifier.new(client: ..., channel: "#alerts"),
#     AuditLogNotifier.new(logger: Rails.logger)
#   ]
# )
# frozen_string_literal: true

module Healthcare
  module AI
    # Dependency Inversion: high-level orchestrator
    # depends on abstractions, not concrete classes.
    class PatientAnalysisService
      def initialize(
        builder:,
        pipeline:,
        notifiers: []
      )
        @builder   = builder
        @pipeline  = pipeline
        @notifiers = notifiers
      end

      # @param patient [Patient]
      # @param records [Array<MedicalRecord>]
      # @return [AnalysisResult]
      def analyze(patient:, records:)
        context = @builder.build(
          patient: patient,
          records: records
        )

        result = @pipeline.run(context)

        broadcast(:analysis_complete, result)

        AnalysisResult.new(
          context:    result,
          flagged:    result.risk_score > 0.75,
          created_at: Time.now.utc
        )
      rescue => e
        broadcast(:analysis_failed, nil)
        raise
      end

      private

      def broadcast(event, context)
        @notifiers.each do |notifier|
          notifier.notify(
            context: context,
            event:   event
          )
        rescue Notifier::NotificationError => e
          Rails.logger.warn(
            "Notifier failed: #{e.message}"
          )
        end
      end
    end

    # Value object — immutable analysis result.
    AnalysisResult = Data.define(
      :context,
      :flagged,
      :created_at
    )

    # Value object — immutable patient snapshot.
    PatientContext = Data.define(
      :id,
      :age,
      :diagnoses,
      :vitals,
      :risk_score
    )
  end
end

# Wiring (e.g. in a Rails initializer)
#
# Healthcare::AI::PatientAnalysisService.new(
#   builder:   PatientContextBuilder.new(...),
#   pipeline:  InferencePipeline.new(steps: [...]),
#   notifiers: [
#     SlackNotifier.new(client: ..., channel: "#alerts"),
#     AuditLogNotifier.new(logger: Rails.logger)
#   ]
# )

Senior Software Engineer

Building AI-powered solutions for healthcare & SaaS

15+ years architecting scalable backend systems, conversational AI platforms, and data-driven products.

Let's Talk View Work

Open to new collaborations

Companies I've worked with

Recommendations

View all recommendations →

What I Do

Services

Backend Engineering

Scalable API design, microservices architecture, and robust backend systems built with Ruby on Rails, GraphQL, and modern tooling.

AI & Voice Systems

Conversational AI pipelines, LLM integrations, speech-to-text and text-to-speech systems for healthcare and enterprise applications.

SaaS Development

End-to-end SaaS product development — from database design and billing to real-time features and production reliability.

Pricing

Membership Plans

Access senior-level engineering on demand. Scale your development without the overhead of a full-time hire. Pause or cancel anytime.

Standard

$4995 /mo

Perfect for getting started with dedicated engineering support.

One request at a time
Average 48-hour delivery
Unlimited revisions
Ruby on Rails & backend
Frontend & API development
Async communication
Pause or cancel anytime

Get Started

Pro

$7995 /mo

For teams that need dedicated senior engineering on an ongoing basis.

Two requests at a time
Average 48-hour delivery
Unlimited revisions
Full-stack development
AI & voice integrations
Architecture & code reviews
Direct Slack/video access
Pause or cancel anytime

Get Started

Custom

Let's Talk

Tailored solutions for enterprise needs. Let's discuss your requirements.

Custom request volume
Priority delivery
Unlimited revisions
Team embedding option
Dedicated Slack channel
Weekly strategy calls
Custom contract terms
Full-stack + AI/ML scope

Not sure which plan fits? Book a free intro call to discuss your needs.

Career

Work

Full CV →

Organizations I’ve partnered with as a software engineer, contributing to real products, production systems, and long-term technical foundations.

Action Network

Current

2018 —

Core backend engineer on Action Builder, a new organizing CRM product. Designed and implemented GraphQL schema powering relationship mapping, network visualization, and organizer workflows.

New York City, United States · Remote · Contract

Ruby on Rails GraphQL AngularJS PostgreSQL

Wendi

2023 — 2025

Led development of an AI voice assistant platform for automated patient intake, insurance verification, and multichannel conversations in healthcare. Architected end-to-end patient workflow engine and real-time conversational AI pipelines.

New York City, United States · Remote · Contract

Ruby on Rails Python React AWS AI/ML APIs WebSockets

HuntClub

2022

Developed and shipped features for a talent-matching platform used by thousands of recruiters and hiring managers. Built full-stack features improving recruiter workflows and candidate pipeline management.

Chicago, United States · Remote · Contract

Ruby on Rails React

The Neat Company

2020 - 2022

Built and maintained backend microservices for Neat's core platform, led a 3-month Rails upgrade across multiple major versions on a legacy application, and coordinated development with other engineers to modernize and support the company's backend services.

Philadelphia, United States · Remote · Contract

Ruby on Rails Node.js TypeScript Microservices

CrazyEgg

2019

Re-architected signup flow and ran 12 A/B tests, lifting conversion by +18%. Integrated Elasticsearch into analytics dashboard, cutting load time from 4s to 800ms. Built Shopify integration driving 5% retention increase.

Cerritos, United States · Remote · Contract

Ruby on Rails Elasticsearch A/B Testing AWS (S3 Kinesis Lambda) Kafka Docker

Envato

2017 — 2018

Built and improved a managed WordPress hosting platform with multi-service architecture. Designed and implemented automated WordPress backup system for thousands of hosted sites.

Melbourne, Australia · Remote · Contract

Ruby on Rails AWS WordPress

Pressed

2016 — 2017

Founding engineer on a greenfield WordPress hosting platform. Built the entire stack from scratch using Ruby on Rails on AWS, including site provisioning, DNS configuration, and SSL management.

New York City, United States · Remote · Contract

Ruby on Rails AWS (EC2 Route 53 S3 SQS)

ReferralCandy

2015 — 2016

Shipped product features and streamlined e-commerce platform integrations for a referral marketing SaaS serving thousands of merchants.

Singapore, Singapore · On-site · Contract

Ruby on Rails Shopify Magento WooCommerce

Site5

2015

Built internal CRM and client-facing management tools, a white-label managed WordPress product, and custom automation tooling for staff operations.

Dallas, United States · Remote · Contract

Ruby on Rails Python AWS

WWWH

2015

Built internal CRM and client-facing management tools, a white-label managed WordPress product, and custom automation tooling for staff operations.

Goiânia, Brazil · Remote · Contract

Ruby on Rails Python AWS

Critsend

2012 — 2013

Built a next-generation email deliverability platform in Python and maintained a distributed transactional email service handling high-volume sends. Developed a server reputation monitoring module (blacklist tracker) and a billing application for the new product line.

San Francisco, United States · Remote · Contract

Python Distributed Systems Email Infrastructure

Side Projects

Projects

Bootstrapped side projects built end-to-end — from concept to production — driven by real problems and long-term curiosity.

Chatified

personal Active

2025 - present

AI Voice & Messaging Platform with multi-channel support for Businesses.

Ruby on Rails AI LLM Prompt Engineering StimulusJS Turbo TailwindCSS Kamal Docker WebSockets RAG Vector database Alpine.js TTS/STT

MailMachine

personal Active

2024 - present

AI-Powered Email Triage & Automation. Email marketing platform with automation, analytics, and deliverability tools.

Ruby on Rails Redis AWS SES StimulusJS TailwindCSS Turbo Kamal Docker Solid Queue Sidekiq

Maior Desconto

personal Closed

2011 — 2013

Group-buying marketplace in Brazil with $700K+ sales, 41K+ users, and 17K paying customers.

Ruby on Rails Email Marketing Bootstrap Sidekiq PostgreSQL Redis

Mailtrack

personal Closed

2009 — 2010

Email marketing platform with campaign automation and analytics.

Ruby on Rails Redis EventMachine AWS SES

Kivu

personal Closed

2016 — 2017

Simple e-commerce platform for small businesses and individuals.

Ruby on Rails PostgreSQL Redis Sidekiq

Impact

Results That Matter

+18%

Conversion lift via A/B testing

CrazyEgg

Performance improvement on analytics

CrazyEgg

100K+

Students monitored in engagement system

State Gov

$700K+

Revenue from bootstrapped marketplace

Maior Desconto

41K+

Registered users on marketplace

Maior Desconto

30K

Monthly payouts processed

State Gov

15+

Years of Experience

Building production systems

10+

Companies

From startups to enterprises

100K+

Users Served

Across platforms built

Countries Visited

Global perspective

About

Newton Garcia

Senior Software Engineer with 15+ years of experience, most recently leading the development of an AI voice assistant SaaS for healthcare providers. Built the platform from scratch, including core workflows, backend systems, and integrations with healthcare tools and EHR-related systems.

Background across SaaS, e-commerce, and cloud platforms, with a strong focus on backend-heavy systems, data-driven product work, and production reliability.

Founded two companies — including a group-buying marketplace that generated over $700K in sales — and contributed to open-source projects like graphql-ruby.

Languages

Portuguese, English, Spanish

Traveled

45 countries →

Status

Available

Newton Garcia on the Great Wall of China

GitHub LinkedIn X

Stack

Technical Skills

Languages

Ruby Python JavaScript TypeScript Elixir Rust R

Backend & APIs

Ruby on Rails NodeJS REST APIs GraphQL WebSockets Background Processing Sidekiq Kafka

Frontend

Turbo/Hotwire React Tailwind CSS Stimulus

Data & Search

PostgreSQL MySQL Redis Elasticsearch Vector Databases (pgvector Pinecone)

Infrastructure

AWS (Lambda S3 RDS CloudWatch) Docker Kamal Ansible Terraform Heroku CI/CD

Observability

Datadog New Relic Sentry Logtail Error Monitoring Performance Monitoring

AI & Voice

LLM Integrations Conversational AI RAG Speech-to-Text Text-to-Speech LangChain OpenAI Prompt Engineering

Contact

Let's build
something great.

I’m always open to discussing interesting projects and future partnerships

Get in Touch

newxhost@gmail.com

Phone

+55 62 98163-1780

Online

github.com/newx linkedin.com/in/newtongarcia x.com/newton_garcia

Building AI-powered solutions for healthcare & SaaS

Services

Backend Engineering

AI & Voice Systems

SaaS Development

Membership Plans

Standard

Pro

Custom

Work

Action Network

Wendi

HuntClub

The Neat Company

CrazyEgg

Envato

Pressed

ReferralCandy

Site5

WWWH

Critsend

Projects

Chatified

MailMachine

Maior Desconto

Mailtrack

Kivu

Results That Matter

Newton Garcia

Technical Skills

Languages

Backend & APIs

Frontend

Data & Search

Infrastructure

Observability

AI & Voice

Let's buildsomething great.

Let's build
something great.