Senior Software Engineer & Architect · Backend · APIs · Integrations

Kurt Geminic Bautista

I build and run production software. I own the work from the first requirements to support after launch.

  • 10+ years in production software (since 2015)
  • TypeScript · Node.js · React · Azure · AWS
  • Philippines (UTC+8) · remote

About

I’m a senior software engineer with more than 10 years of building and running production software for product companies and client teams. Most of my work is in TypeScript, Node.js and React: backend services, APIs and full-stack web apps.

Role
Senior Software Engineer & Architect
Currently
Independent architecture and engineering work, since Dec 2023
Focus
Backend services and APIs, full-stack web applications, existing production systems
Based in
Philippines (UTC+8) · remote

Selected work

Case studies

Some of the work from my jobs and partner projects. I don’t name partner clients, and I don’t show any client code or data.

01

IoT Data Platform

Partner work · Confidential client

Part-time architecture engagement

Senior Software Architect

  • IoT
  • Parquet
  • DuckDB
  • OneStream
  • Azure Key Vault
Problem
A client needed the data from its IoT devices in its finance and operations reporting, without building and running a separate data warehouse.
What I delivered
Designed how device data flows into the platform: checked and stored as Parquet files, queried with DuckDB, and fed into OneStream. Defined the data contracts between the device pipeline and OneStream.
Approach
Kept it simple to operate: files and an embedded query engine instead of another database server, and credentials in Azure Key Vault instead of code or config.
Outcome
Device data reaches finance and operations reporting in OneStream, with no data warehouse to run.

02

Analytics Reporting APIs

Squareflo · Internal analytics platform

2023–2025

Senior Software Engineer: reporting API design and implementation

  • TypeScript
  • Node.js
  • REST APIs
  • AWS
Problem
Internal teams waited too long for the analytics reports they needed for daily operations.
What I delivered
Designed and built the REST endpoints for reporting, after working with the teams who used the reports to see what they actually needed.
Approach
Built the endpoints around how people use the reports rather than around the database tables, and kept the backend simple to run and maintain.
Outcome
Reports came back faster and more reliably for the teams that depend on them.

03

Order & Delivery Mobile App Template

Squareflo · Reusable mobile product

2023–2025

Senior Software Engineer: template architecture and implementation

  • Mobile / iOS
  • REST APIs
  • Node.js
  • TypeScript
Problem
Without a template, every new order-and-delivery customer would need a mobile app built from scratch.
What I delivered
Built the reusable app template, including the core ordering and delivery flows.
Approach
One configurable app backed by APIs, so a new customer starts on code that already runs in production.
Outcome
The template was reused for several customers in the order and delivery industry.

04

StanzaPlus Calendar & Integrations

Stanza · Consumer product

2020–2023

Senior Full-Stack Engineer

  • TypeScript
  • React
  • Node.js
  • REST APIs
  • Third-Party APIs
Problem
StanzaPlus users wanted their event schedules in the calendars and tools they already use.
What I delivered
Designed and built the add-to-calendar flows and third-party integrations, frontend and backend.
Approach
Worked with product managers and designers from roadmap planning to release, and wrote an implementation plan before building.
Outcome
StanzaPlus users can add their event schedules to their own calendars and connect the tools they already use.

Backend

Backend architecture

How I design backend systems. Two come from my own code; the other two are reference designs, labelled as such.

From my code · jwt-auth-kit

Authentication service

A standalone auth service: short-lived access tokens any API can verify on its own, and rotating refresh tokens that detect theft.

Architecture of jwt-auth-kit, an authentication serviceClients call an Express 5 service through security headers, CORS and per-email and per-IP rate limits. Routes use a token service that signs Ed25519 access tokens and rotates single-use refresh tokens. Refresh tokens are stored only as hashes, in token families, through a store interface backed by PostgreSQL or memory. Public keys are published as a JWK Set so other APIs verify access tokens without calling the service. A cleanup job deletes expired token families.Clientweb / mobile appjwt-auth-kit · Express 5Security headers · CORSstrict CORS · CSRFRate limitssliding windowper email · per IPRoutes/auth/login · refresh · logout/me · /passwordToken serviceEd25519 access JWT (15 min)single-use refresh tokensreuse → revoke the familyStore interfaceatomic rotate + revokehash(refresh token) onlyPostgreSQLusers · token familiesSQL migrationsCleanup jobdeletes expired familiesJWK Set/.well-known/jwks.jsonpublic keys, cached 5 minOther APIsverify the JWT locally,no call to authHTTPSpublishesfetch keysBearer access token

Key decisions

  • Access tokens are Ed25519-signed and verified against a published JWK Set, so other services never call the auth service per request.
  • Refresh tokens are single use and stored only as hashes; replaying a used one revokes the whole session family.
  • Rotation is one atomic store operation, so two concurrent refreshes can’t both succeed.
  • Per-email and per-IP sliding-window limits run before any password hashing, and reveal nothing about which emails exist.

Built with

  • TypeScript
  • Express 5
  • PostgreSQL
  • Ed25519 / JWKS
  • Docker
  • Vitest

From my code · api-break-check

Breaking-change gate for APIs

A CLI and GitHub Action that compares two versions of an OpenAPI spec and fails the build before a breaking change reaches clients.

Architecture of api-break-check, a CI gate for breaking API changesThe base spec from a git ref and the head spec from the working tree are loaded and normalised from OpenAPI 3.0, 3.1 or Swagger 2.0, references are resolved, and each side becomes an operation model. A rules engine compares the two models and produces findings sorted by severity: breaking, warning, info. Reporters output text, JSON, Markdown for pull requests, SARIF for code scanning and JUnit for CI, and the exit code fails the build on breaking changes.Base specorigin/main:openapi.yamlHead specthe pull requestLoad & normaliseOpenAPI 3.0 / 3.1Swagger 2.0 → 3.xgit refs · remote URLsOperation model$refs resolvedper operation: params,bodies and responsesRules engineoperations · parametersrequest bodies · responsesschemas · enums · formatssecurity · servers · webhooksseverity: breaking › warning › infofindings, sorted by severityText · JSONterminal and scriptsMarkdownpull request commentSARIFGitHub code scanningJUnit XMLCI test reportsExit code 1fails CI / GitHub Action

Key decisions

  • Both specs are normalised into the same operation model first, so moving a schema into components or renaming a path parameter isn’t reported as a change.
  • Each kind of change is a separate rule with a severity, and teams can override severities or accept a specific change in config.
  • One set of findings feeds every reporter: text, JSON, Markdown, SARIF and JUnit, so it fits any CI system.

Built with

  • TypeScript
  • Node.js
  • OpenAPI 3.x
  • GitHub Actions
  • SARIF

Reference design · from partner work

C# / .NET backend on Azure

The kind of system I build on partner projects with C# / .NET and Azure. Drawn as a reference design, not a client’s system.

Reference design for a C# / .NET backend on AzureClients sign in with Microsoft Entra ID and call the system through Azure Front Door and Azure API Management, which validates tokens, applies rate limits and versions the API. An ASP.NET Core API on Azure App Service reads secrets from Key Vault through a managed identity and uses Azure SQL Database, Azure Cache for Redis and Blob Storage. Slow work goes through Azure Service Bus to Azure Functions. Application Insights collects telemetry, and an Azure DevOps pipeline deploys to a staging slot that is swapped into production.Clientsweb SPA · mobileAzure Front DoorWAF · CDN · TLSAPI Managementvalidates JWTrate limits · versionsASP.NET Core APIC# · .NETAzure App ServiceEF Core · clean layersEntra IDOAuth 2.0 · OIDCKey Vaultread via managed identityAzure SQLEF Core migrationsCache for Redishot reads · sessionsBlob Storagefiles · exportsService Busqueues · topics · DLQAzure Functionsemails · PDFspartner integrationsAzure DevOps pipelinebuild · test · deploy to staging slotwarm up · swap to productionApplication Insightstraces · logs · alertssign intoken keyssecretstriggersdeploytelemetry

Key decisions

  • Front Door and API Management sit in front of the API, so TLS, the firewall, token validation, rate limits and versioning stay out of business code.
  • Identity is delegated to Entra ID: the API validates tokens and never stores passwords.
  • No secrets in configuration: the API reads Key Vault through its managed identity.
  • Slow work (emails, PDFs, partner integrations) goes through Service Bus to Functions, with retries and a dead-letter queue, so requests stay fast.
  • Zero-downtime releases: the pipeline deploys to a staging slot, warms it up and swaps; database migrations are backward compatible so either version can run.

Typical stack

  • C#
  • .NET / ASP.NET Core
  • EF Core
  • Azure SQL
  • Service Bus
  • Azure Functions
  • Azure DevOps

Reference design

Booking platform backend

How I’d build a booking system like the travel, ticketing and appointment products I’ve worked on. It’s a reference design, not any one client’s system.

Reference design for a booking platform backendWeb and mobile clients reach a booking API through an API gateway. The booking API places short holds on inventory in Redis, records bookings and an outbox in PostgreSQL in one transaction, and charges a payment provider with an idempotency key. The booking API charges the payment provider, which confirms back through verified webhooks along the same link. Events from the outbox go to a queue, and workers send confirmations, sync with suppliers and create invoices.Clientsweb · mobileAPI gatewayauth · rate limitsBooking APINode.js · TypeScriptidempotency keyshold → pay → confirmversioned RESTRedisavailability cacheholds with a TTLPostgreSQLbookings · paymentsoutbox (same txn)Paymentsprovider API+ signed webhooksQueueoutbox eventsWorkersconfirmationssupplier syncinvoicesSuppliers · emailinventory / partner APIstransactional emailholdtxncharge with idempotency key ⇄ verified webhook

Key decisions

  • Short holds with a TTL in Redis prevent double booking while the customer pays, and expire on their own if payment never completes.
  • Every booking and payment request carries an idempotency key, so retries from flaky mobile networks never charge twice.
  • The booking and its outbox event are written in one transaction; workers publish from the outbox, so no confirmation is lost or sent twice.
  • Payment webhooks are verified and handled in the background. The payment provider decides whether a payment went through; the browser doesn’t.

Typical stack

  • Node.js
  • TypeScript
  • PostgreSQL
  • Redis
  • Queue workers
  • Webhooks

Career

Experience

  1. Dec 2023 – Present

    Senior Software Engineer & Architect

    Independent · Partner Projects

    Independent partner work, including part-time architecture engagements. From December 2023 to September 2025 it ran alongside the Squareflo role.

    • Own the technical side of client and product projects with a long-term development partner: requirements, architecture, building, deployment and maintenance.
    • Design and build full-stack apps and backend services: REST APIs, data models, authentication, business logic and third-party integrations, mostly in TypeScript and Node.js, and in the client’s own stack when their system needs it.
    • Take over existing production codebases, find the root cause of problems across frontend, API, database and infrastructure, and refactor them to be faster, more reliable and easier to maintain while users keep working.
    • As a part-time architect, designed a client’s IoT data platform: device data checked and stored as Parquet, queried with DuckDB and fed into OneStream for finance and operations reporting, with credentials in Azure Key Vault.
    • Turn incomplete specs into technical plans, make the trade-off calls, and lead design reviews.
    • Architecture
    • IoT & Data Platforms
    • Backend & APIs
    • Azure
    • Production Debugging
  2. Sep 2023 – Sep 2025

    Senior Software Engineer

    Squareflo

    • Designed and built, with a small team of engineers, the REST reporting APIs that made internal analytics reports faster and more reliable.
    • Built reusable components for the internal UI library and reviewed their adoption across teams, so product teams stopped rebuilding the same interface elements.
    • Redesigned and sped up an internal customer-support app, so the support team could answer customers faster.
    • Built a reusable mobile app template for order and delivery businesses, later used for several customers in the industry.
    • Mentored frontend developers on React, coding practices and internal standards, and reviewed implementation approaches across the team.
    • TypeScript
    • React
    • Node.js
    • AWS
    • Mentoring
  3. Jan 2020 – Aug 2023

    Senior Full-Stack Engineer

    Stanza

    • Designed and built new StanzaPlus features, frontend to backend, including add-to-calendar flows and third-party integrations, working closely with product managers and designers.
    • Shaped the technical side of product planning and the roadmap, turning requirements into implementation plans.
    • Kept the codebase consistent and easy to maintain through code reviews, coding standards, and steady improvements to the architecture, tooling and dev process.
    • TypeScript
    • React
    • Node.js
    • Integrations
    • Code Review
  4. Jul 2015 – Dec 2019

    Freelance Software Engineer

    Toptal (freelance network)

    • Built custom software for clients in healthcare, e-commerce and retail, working directly with each client to turn their requirements into solutions that fit their existing systems.
    • Kept clients up to date on progress, risks and technical decisions, and raised code quality and performance through code reviews.
    • JavaScript
    • TypeScript
    • Node.js
    • REST APIs
    • Automated Testing

Education

Bachelor of Science in Computer Engineering

University of the Philippines Diliman · Diliman, Quezon City · Jul 2015

Languages

English · Professional Working Proficiency

Filipino · Native / Fluent

Tools

Technology stack

Grouped by how much I’ve used each one. I pick whatever stack suits the problem and the team.

Core Strengths

What I use day to day and can lead on.

  • TypeScript
  • JavaScript
  • Node.js
  • Express
  • React
  • REST API Design
  • Third-Party Integrations
  • SQL

Additional Experience

Used in production, just not every day.

  • Python
  • C# / .NET
  • Java
  • PHP
  • Next.js
  • PostgreSQL
  • MySQL
  • MongoDB
  • Redis
  • AWS
  • Azure
  • Docker
  • CI/CD (GitHub Actions)
  • iOS (Swift)
  • Parquet & DuckDB
  • OneStream

Contact

Let’s talk

Email is the fastest way to reach me. If you’d rather talk through a project or a production problem, book a 30-minute call.