We’re hiring a US-based Mid‑Level Software Developer to help us build, run, and improve the systems our clients rely on every day. This isn’t a role where you disappear into a backlog or ship code and never think about it again.

You’ll work on production systems that handle billing, integrations, data movement, and operational workflows. The work is meaningful, the expectations are clear, and the people you’ll work with care about doing things well and not making work harder than it needs to be.

If you like ownership, clean systems, and solving real problems with smart, kind people, keep reading.

How We Work (This Matters)

Before tools or titles, this is what we care about:

• People First
  Relationships over transactions. We assume good intent, communicate clearly, and try to be decent humans while doing serious work.

• Excellence as a Standard
  Quality isn’t a stretch goal. If software runs real businesses, it needs to hold up on an ordinary Tuesday.

• Constant Innovation
  We’re always improving. That means questioning defaults, cleaning up old decisions, and replacing duct tape with something sturdier.

• Infectious Energy
  We enjoy solving problems. Curiosity, momentum, and a sense of humor go a long way here.

What You’ll Be Responsible For

Owning production systems
You’ll design, build, ship, and operate features and fixes end-to-end. When something goes live, you stick around to make sure it keeps working.

Working across multiple codebases
You’ll own work across several active services (including MoneyFlow, PIF Perfect, and DialerSync) and manage priorities without needing constant direction.

Protecting the important stuff
Billing, payments, and data flows matter. You’ll ship changes using staging, feature flags, and tested rollback plans so mistakes are manageable, not catastrophic.

Making things more reliable over time
You’ll define reliability targets, add useful observability, keep alerts sane, and follow through after incidents.

Building integrations that don’t crumble
You’ll work with third-party APIs and integrations and design them to handle real-world messiness like rate limits, retries, and upstream changes.

Leaving the codebase better than you found it
Readable code, thoughtful reviews, and refactors that make future work easier instead of harder.

Documenting just enough
Clear READMEs and runbooks that help people understand and operate the system without digging through Slack archaeology.

Reducing developer friction
Better CI/CD, fewer flaky tests, smoother local setup, and less time wasted on avoidable problems.

Working async, on purpose
Clear written updates, early heads-ups on blockers, and minimal meetings. We like talking, we just don’t like wasting time.

As you grow, you’ll help scope work, mentor through reviews or pairing, and influence technical direction across services.

What “Good” Looks Like Here

• Features ship predictably without heroics

• Rollbacks are fast, tested, and boring

• Services meet reliability targets

• Integrations stay stable even when upstream systems change

• Documentation stays current because it’s actually useful

• You don’t need micromanagement to do good work

What We’re Looking For

You must have

• Professional experience building and operating production services in Node.js / JavaScript

• Hands-on experience with AWS (or similar cloud) and MongoDB

• Strong Git and CI/CD discipline

• Experience owning high-risk production paths (billing or data-critical systems)

• Real experience with third-party APIs and integrations

• Clear written communication and comfort working async

• Ability to onboard into unfamiliar codebases quickly

• Comfort making independent technical decisions

• Authorization to work in the United States

Nice to have

• Vercel or serverless experience

• Supabase or Postgres familiarity

• CRM or telephony/dialer integrations

• Payments or subscription systems

• Practical use of AI tools to speed up understanding and testing

• A track record of improving developer experience

Why This Role Exists

We’re growing, and the systems we run are becoming more important. We want someone who enjoys building dependable software, communicating clearly, and steadily improving things without unnecessary stress.

If you want to do meaningful work with people who care about quality, relationships, and having a good time while doing serious work, this role is worth your attention.