Skip to content

Experienced hires

Engineering & Product

Engineers, product managers and designers who build and own the software that banks, health systems and public agencies run every day, under the security and compliance rules those clients answer to.

Open roles in Engineering & Product

14 open roles. Every listing shows its pay range.

See all 14

The work

Software that has to keep working

Our products sit inside regulated workflows: a credentialing decision that lets a clinician see patients, a collateral position a bank reports to its regulator, a citizen service a state must keep open. You own what you build, from design to production, and you are accountable for how it behaves when it matters.

Product engineering

Backend, full-stack and frontend engineers in the Fusion Center and our industry divisions build our own SaaS products: wealth platforms in Toronto, collateral monitoring in Buenos Aires, citizen services in Yerevan, credentialing in Boston. You design APIs and data models, write and test the code, and support it once it is live.

Integration and interoperability

Healthcare engineers in Auckland and Mexico City connect our products to electronic health records and payer systems with HL7 v2 and FHIR. The hard part is rarely the standard; it is the variation between how two hospitals use it, and making failures visible before a clinician notices.

Platform and security engineering

Staff engineers in San Francisco build the shared platform every product runs on: identity, secrets, build pipelines and the security checks that gate every release. Your users are other engineers, and your measure is how easy it is for them to do the safe thing.

Quality engineering

QA automation engineers build the test suites and environments that let teams release often without breaking what clients depend on, including tests for access control, audit logging and data retention that a regulator might ask about.

Product management

Product managers in New York and Boston own problems such as hospital operations and healthcare interoperability. You spend time with nurses, schedulers and integration teams, decide what to build next, and are accountable for whether it changed the outcome it was meant to.

Product design

Designers in San Francisco shape experiences for patients and the staff who serve them, where clarity is a safety property: the wrong default on a form can delay care. You test with real users, design for accessibility from the start, and work with engineers on the details.

Open roles

Roles in this track

These roles were open when this page was written. Listings change, so check open roles for the current list. Every listing shows its pay range.

RoleLevelOfficeTeam
Staff Software Engineer, Platform SecurityStaffSan FranciscoFusion Center
Senior Backend Engineer, Dynamic Collateral MonitorSeniorBuenos AiresFusion Center
Senior Full-Stack Engineer, Wealth PlatformsSeniorTorontoFusion Center
Senior Software Engineer, Credentialing PlatformSeniorBostonHealthcare Solutions
Senior Software Engineer, Healthcare InteroperabilitySeniorAucklandHealthcare Solutions
Frontend Engineer (React), Citizen ServicesMidYerevanFusion Center
Integration Engineer (HL7 / FHIR)MidMexico CityHealthcare Solutions
QA Automation EngineerMidBuenos AiresFusion Center
Product Manager, Healthcare InteroperabilitySeniorNew YorkHealthcare Solutions
Product Manager, Hospital OperationsSeniorBostonHealthcare Solutions
Senior Product Designer, Patient ExperienceSeniorSan FranciscoHealthcare Solutions

Each listing says whether the role is hybrid or on-site. In some countries you are employed through an Employer of Record partner while working on a Moraph team; the listing says when this applies.

What we look for

What each level looks like in this track

Our listings use Entry, Mid, Senior and Staff / Lead. The experienced hires page explains the levels across Moraph; this is what they mean for engineers, product managers and designers.

Mid

You take a well-scoped feature or integration from design to production on your own: you clarify requirements, write and test the code or design, ask for review early, and support it once it is live. You know when a change touches security, audit logging or patient or customer data, and you raise it before you merge.

Senior

You own problems that arrive ambiguous: a slow integration with no obvious cause, a product area with competing requests. You break them into work others can pick up, make the trade-offs explicit, lead a small project, and mentor. Your design documents are read by people outside your team and they change decisions.

Staff / Lead

You set direction across several teams: a platform others build on, a standard for how we integrate with health records, an architecture that will hold for years. You influence without authority, spot the problems teams cannot see from inside, and make the safe path the easy path.

For product managers, the same ladder applies to scope: Senior owns a product area and its outcomes; Lead roles shape a portfolio and the strategy behind it. Designers follow the same pattern for the experiences they own.

How we interview

The loop for this track

Usually two to three interviews after the recruiter screen. We tell you in advance who you will meet and what to prepare, and you choose the times on your application page.

  1. Recruiter screen

    Thirty minutes on your experience, what you are looking for, the role and its posted pay range, and any questions you have about the team or the process.

  2. Hiring manager

    A conversation about work you have done: a system you designed, a product decision you made, a time something you shipped went wrong. Expect follow-up questions about the details and the trade-offs.

  3. Practical exercise

    For engineers, a system design discussion or a code review of a short, realistic change, done live with an engineer from the team. For product managers, a product problem worked through with a product leader. For designers, a walk-through of your portfolio and a short design critique. You are told the format in advance. If it is a take-home, it has a stated time limit, and it is never real production work.

  4. The team

    A conversation with the people you would work with, often including someone from another discipline: a designer for an engineer, an engineer for a product manager. They want to know how you work, explain and disagree.

Interviewers score against the role’s competencies and write their feedback before seeing anyone else’s. Offers are always within the posted range. See How we hire.

Sample questions

Questions like the ones we ask

These are samples like the ones we use, written to help you prepare. Your interviewers will ask their own.

Hiring manager

Walk us through a system you designed that is still in production. What would you change now?

What a strong answer covers:

  • The problem and the constraints at the time, including the ones that were not technical (deadline, team, budget).
  • Two or three decisions you made and the alternatives you rejected, with reasons.
  • What happened in production: load, failures, what surprised you.
  • A specific change you would make with what you know now, and what it would cost to make it.
Tell us about a release that caused a problem for users. What did you do in the first hour, and afterwards?

What a strong answer covers:

  • How you found out, and how long that took.
  • The first decision: roll back, roll forward or contain, and why.
  • Who you told and when, including people outside engineering.
  • What changed afterwards in tests, monitoring or release process, without blaming a person.
(Product) Describe a feature you decided not to build, even though a customer asked for it.

What a strong answer covers:

  • The request and what the customer was really trying to achieve.
  • The evidence you used: how many users, how often, what it would displace.
  • How you said no, and what you offered instead.
  • Whether you were right, and how you would know.
How have you handled working with a team in another time zone on the same codebase?

What a strong answer covers:

  • How work was split so teams were not waiting on each other.
  • How decisions were written down and handed over.
  • A specific problem the time difference caused, and what fixed it.

Practical

Design an API that lets a patient cancel an appointment from a mobile app on a weak connection.

What a strong answer covers:

  • Idempotency: a retry must not cancel twice or cancel the wrong booking.
  • Authorization: the patient may cancel their own appointment, a caregiver only with permission, and every action is logged.
  • What the clinic sees, and how the slot is offered to someone else.
  • Failure cases: the clinic system is down, the appointment has already started, the cancellation arrives late.
In this code review, a pull request adds a new field to a record containing customer data. What do you check?

What a strong answer covers:

  • Whether the field is needed at all, and who can read it.
  • Logging: is the value written to logs, analytics or error reports where it should not be?
  • Migration: existing records, defaults, backfill and rollback.
  • Retention and deletion: does the field follow the record’s retention rules and erasure requests?
  • Tests that prove the access rules, not just the happy path.
An HL7 interface from one hospital starts dropping about one message in a thousand. How do you find out why?

What a strong answer covers:

  • Confirming the drop is real and measuring it: message counts at each hop, not just errors.
  • Looking for a pattern in the dropped messages (message type, segment, sending system, time).
  • Checking acknowledgements and retries, and what happens to messages that fail validation.
  • How you would make the next drop visible within minutes.
(Product) Hospital schedulers say the new scheduling screen is slower than the old one. What do you do?

What a strong answer covers:

  • Watching schedulers work before changing anything, and measuring time per task.
  • Separating perceived slowness (more clicks, unfamiliar layout) from real latency.
  • A small change you could ship quickly, and what would tell you it worked.

Team

Tell us about a time you disagreed with a technical or product decision and were overruled.

What a strong answer covers:

  • How you made your case: evidence, not volume.
  • How you supported the decision once it was made.
  • What happened, and what you learned about making the case next time.
How do you help a less experienced colleague without doing the work for them?

What a strong answer covers:

  • Asking questions before giving answers.
  • Reviews that explain why, not just what to change.
  • A specific person you helped and how you knew it worked.
What do you need from a product manager (or engineer, or designer) to do your best work?

What a strong answer covers:

  • Something specific and honest, not a list of virtues.
  • What you give back in return.
  • An example of a working relationship that went well, and one that did not.

A practical exercise to try

Try a design exercise

An exercise like the ones we use in the system design conversation. Read it, sketch your answer and do the numbers before you open ours.

Practice exercise · system design · 45 minutes

Keeping clinicians’ credentials current

The health system and every number in this exercise are fictional, made up for practice.

Background

A regional health system uses our credentialing platform for 25,000 clinicians. Each clinician holds several credentials: state licenses, controlled substance registrations, board certifications and others. Every credential must be re-verified with its primary source before it expires. If a credential lapses, the clinician cannot see patients until it is verified again, so a missed check takes a clinician off the schedule.

Exhibit 1 · Credentials and how they are verified
ItemValue
Clinicians25,000
Credentials per clinician (average)6
Average validity of a credential24 months
Share verified through a primary source API85%
Share verified by hand (no API: phone, email or portal)15%
Staff time per hand verification12 minutes
Hours a full-time verification specialist works on this per month150
Slowest source API limit60 requests a minute

Your task

  1. How many verifications does the platform need to run in an average month? How many are done by hand, and how much staff time do they take?
  2. Sketch the design: how the platform decides what to verify and when, how it calls the sources, and what happens when a check fails.
  3. What would you monitor so that no clinician is taken off the schedule by surprise?
One way to approach it

The numbers. 25,000 × 6 = 150,000 credentials. With an average validity of 24 months, about 150,000 ÷ 24 = 6,250 verifications a month. 15% are by hand: 937.5, or about 940 a month, at 12 minutes each = 11,250 minutes = 187.5 hours a month, or 1.25 specialists at 150 hours. The API side is about 5,300 calls a month; even at the slowest source’s 60 a minute, a month’s worth takes under 90 minutes of calls. Throughput is not the problem. Timing and the manual queue are.

The design. A scheduler creates a verification task for each credential well before it expires, for example 90 days ahead, with reminders at 60 and 30 days. Tasks go on a queue per source, with rate limits set per source and retries with backoff. Each task carries an idempotency key (credential and expiry date) so a retry or a duplicate schedule cannot create a second record. Every result, including the raw response or the specialist’s notes and the evidence document, is stored with who verified it and when, because accrediting bodies and payers will ask. Tasks that cannot be done by API go to a work queue for specialists, ordered by expiry date, not arrival.

When a check fails. Distinguish between “the source said no” (the credential is not valid: alert the medical staff office at once) and “we could not get an answer” (the source is down or changed its format: retry, then escalate to a specialist). Never treat a failed call as a pass.

What to monitor. The number of credentials expiring in the next 30 days without a completed verification, by source; the age of the oldest task in the manual queue against the specialists’ capacity; API error rates by source; and a daily check that every active clinician has every required credential on record. The first of these is the one that matters to the hospital: it should be zero, and someone should be paged if it is not.

Strong answers also ask how expiries are distributed. If a state renews every license on the same date, the monthly average hides a peak, and the manual queue needs to be planned for that month, not the average.

Your first 90 days

What the start usually looks like

Typical, not a script: your manager agrees your goals with you in the first week.

  1. Days 1–30

    Learn the system and the rules

    Onboarding on the regulations our clients work under and how we handle their data. Set up your environment, ship a small change through the full review and release process, and read the incident history of the product you will own.

  2. Days 31–60

    Own something real

    Take on a feature, integration or product question of your own. Join the on-call rotation as a shadow if your team runs one. Meet the clients or users of your product with your product manager or customer success colleagues.

  3. Days 61–90

    Improve one thing

    Deliver your first project, write up what you learned, and propose one improvement to the codebase, the product or the way the team works. Your manager reviews the first 90 days with you in writing.

Where it leads

Paths from here

Deeper in engineering

From Senior to Staff and beyond, setting technical direction for a product, the platform or a practice such as interoperability or security engineering, without having to manage people to grow.

Into management

Engineering, product and design managers lead teams and are posted when open. Moving into management is a change of job, not a promotion, and you can move back.

Across Moraph

Engineers move into solutions architecture, site reliability, security or data work; product managers into strategy or client delivery. Our six business units and eleven offices make moves possible without leaving.

Questions

Frequently asked questions

Which languages and tools do you use?

It depends on the product. Listings name the main ones, and you will find teams using common languages and frameworks on AWS, Azure and Google Cloud, with GitLab or GitHub pipelines and security scanning on every change. We hire for how you think and learn more than for a specific stack.

Do I need experience in banking, healthcare or government?

It helps but is rarely required. Onboarding covers the rules our clients work under, and your team teaches the domain. Some roles, such as healthcare integration, list domain experience in their requirements.

Is there an on-call rotation?

Teams that run production services share an on-call rotation, scheduled in advance and supported by Global Resilience Operations, who handle first response around the clock. Product managers and designers are not on call.

How much of the work is new products and how much is maintenance?

Both, and we think the second deserves as much care as the first. Most engineers spend most of their time on products already in use, improving and extending them for clients who depend on them.

Can I work with people in other offices?

Almost certainly, and often every day. Teams in the Americas, Europe and Asia-Pacific share codebases and hand work over across time zones.

Will the practical exercise use my own time?

Usually it is done live, inside the interview. If a team uses a take-home, it has a stated time limit, and it is never production work.