Website:
scriptassist.co.uk
Job details:
📍 Remote – India
💰 ₹25–50 LPA total CTC, depending on experience and scope
🕒 Full-time
Staff Engineer | Node.js | TypeScript | React | Multi-Tenant SaaS | Software Architecture | Technical Leadership
Shape the architecture. Control the quality. Stay hands-on.
Script Assist is looking for a hands-on Staff Software Engineer with deep production experience in Node.js, TypeScript and React to help shape the architecture and technical direction of a complex multi-tenant healthcare SaaS platform.
We are looking for someone who has already worked on a substantial enterprise B2B SaaS product and understands what happens as that product becomes large:
- More modules
- More integrations
- More customer configuration
- More workflow variation
- More roles and permissions
- More historical data
- More dependencies
- More engineers
- More opportunities for seemingly small changes to have unexpected consequences
You may currently be a:
- Staff Software Engineer
- Staff Engineer
- Staff Full Stack Engineer
- Lead Software Engineer
- Principal-level IC
- Senior Technical Lead
- Experienced Senior Software Engineer already operating beyond your formal title
This is not an Engineering Manager position.
It is also not an architect role where you stop working in production code.
You will remain technically hands-on while influencing the quality and direction of engineering well beyond your own implementation work.
About Script Assist
Script Assist is a UK healthcare technology company providing the technology and operating infrastructure behind complex private clinical and pharmacy services.
Our platform connects clinics, pharmacies, prescribers, patients and operational teams.
It supports substantial functionality across:
- Clinical workflows
- Prescribing
- Medication management
- Pharmacy workflows
- Inventory
- Dispensing
- Payments
- Subscriptions
- Fulfilment
- Communications
- Reporting
- Permissions
- Customer configuration
- Third-party integrations
The difficult engineering problem is not any one of these features.
It is how they interact.
A workflow may behave differently depending on:
- Customer
- Clinical service
- User role
- Pharmacy
- Medication
- Configuration
- Integration
- Payment status
- Previous actions
- Operational exceptions
The product therefore needs engineers who can understand local implementation details while simultaneously protecting the coherence of the wider platform.
🧭 Your role
You will take deep technical ownership of a substantial part of Script Assist while helping establish engineering patterns that scale beyond it.
You will move comfortably between:
- Architecture
- Product behaviour
- Node.js services
- React applications
- Databases
- Integrations
- Code review
- Production incidents
- Mentoring
- Technical strategy
You should be able to understand the hardest parts of the codebase without becoming the only person capable of changing them.
Architecture and system design
You will:
- Define domain and module boundaries
- Design backend services and APIs
- Define data ownership
- Review database models
- Design integration patterns
- Establish appropriate shared abstractions
- Improve configuration architecture
- Challenge unnecessary coupling
- Reduce fragile customer-specific behaviour
- Lead important technical migrations
- Help simplify accumulated complexity
You should understand when to introduce:
- Configuration
- Shared services
- Events
- Queues
- Transactions
- APIs
- Feature flags
- Migration layers
and equally importantly, when not to introduce them.
Hands-on engineering
You will remain capable of personally implementing difficult production changes.
That includes:
- Node.js / TypeScript backend development
- React / TypeScript frontend development
- API design
- Database work
- Integration development
- Debugging
- Performance investigation
- Refactoring
- Testing
- Production incident investigation
You should still enjoy working directly with code.
Multi-tenant SaaS complexity
The strongest candidates will have experience with products where many customers share the same platform while behaving differently.
Relevant problems include:
Tenant architecture
- Tenant isolation
- Tenant-aware data models
- Customer-specific configuration
- Organisations and sub-organisations
- Entitlements
- Feature flags
Workflow complexity
- Workflow engines
- State machines
- Rules engines
- Configurable business logic
- Approval flows
- Long-running workflows
- Versioned workflows
- Exception handling
Permissions
- RBAC
- User roles
- Organisation-level access
- Fine-grained permissions
- Auditability
Integrations
- REST APIs
- GraphQL
- Webhooks
- Public APIs
- External systems
- Background jobs
- Asynchronous processing
- Event-driven architecture
Distributed-system behaviour
- Idempotency
- Retries
- Partial failures
- Transactions
- Outbox patterns
- Queues
- Dead-letter handling
- Concurrency
- Reconciliation
- Correlation IDs
Product evolution
- Schema changes
- Data migrations
- Backward compatibility
- Safe rollouts
- Feature flags
- Progressive migrations
- Production monitoring
- Incident recovery
You do not need to have implemented every specific pattern.
We care about whether you have actually solved these kinds of problems.
Technical leadership
A Staff Engineer at Script Assist should improve the work of other engineers.
You will:
- Lead important design reviews
- Review difficult code
- Challenge poor technical decisions
- Establish engineering patterns
- Mentor Senior and mid-level engineers
- Help engineers decompose complex problems
- Document major technical decisions
- Improve testing strategy
- Improve observability
- Help identify technical debt worth solving
- Resolve architectural disagreements
- Work with Product on technical trade-offs
- Raise the quality of engineering across your area
We do not want someone who responds to every difficult problem by saying:
“I'll just build it myself.”
You should be capable of solving the hardest problems while making the people around you increasingly capable of solving them too.
Production ownership
You will take responsibility beyond merge and deployment.
You should care about:
- What happened in production
- Whether customers are seeing unexpected behaviour
- Performance
- Errors
- Failed integrations
- Operational recovery
- Logging
- Monitoring
- Reconciliation
- Incident prevention
A major production incident should result not merely in a patch, but in a better system afterwards.
Essential technical background
We need substantial recent production experience with:
- Node.js
- TypeScript
- React / React.js
- Backend systems
- API design
- Databases
- Distributed applications
- Automated testing
- Git
- Docker
- CI/CD
- Cloud environments
- Production observability
Particularly relevant:
- NestJS
- Express
- Fastify
- PostgreSQL
- MongoDB
- Redis
- GraphQL
- Kafka
- RabbitMQ
- SQS
- Kubernetes
- AWS / Azure / GCP
- Integration testing
- Event-driven systems
One particular database, message broker or cloud provider is not mandatory.
Node.js requirement
We need genuine backend Node.js ownership.
Experience limited to:
- Front-end build tooling
- Server-side rendering
- Simple proxy services
- Thin BFF layers
is insufficient unless you also have substantial Node.js backend experience elsewhere.
Relevant product backgrounds
The most interesting candidates will often come from mature enterprise SaaS products involving:
- Workflow management
- Automation
- CRM
- Identity
- Permissions
- Governance
- APIs
- Developer platforms
- Operational systems
- Enterprise configuration
Potentially relevant engineering environments include:
- Okta / Auth0
- Blue Yonder / JDA Software
- Freshworks
- Diligent
- Postman
- LeadSquared
- Comparable enterprise SaaS businesses
These are examples only.
We assess your actual product ownership, not your employer's brand.
How you should think
We are interested in engineers who ask questions such as:
- What is the real domain boundary here?
- Is this customer-specific or product behaviour?
- Should this become configuration?
- What happens to existing tenants?
- What happens to workflows already underway?
- What happens if the event arrives twice?
- How do we recover from partial failure?
- How do we prove this migration is safe?
- How will another engineer understand this in two years?
- How do we make this simpler rather than merely making it work?
That style of reasoning matters enormously.
Communication and judgement
You will work directly with senior Product and Engineering colleagues across the UK and India.
You should be able to:
- Explain difficult technical concepts clearly
- Challenge assumptions constructively
- Defend technical decisions with evidence
- Understand commercial/product constraints
- Avoid overengineering
- Make pragmatic trade-offs
- Communicate clearly in written English
- Mentor without patronising or micromanaging
Experience
We expect strong candidates will typically have approximately 8–14+ years of software engineering experience.
However, Staff-level scope matters more than calendar years.
You do not necessarily need to hold a Staff title today.
A Lead or exceptional Senior engineer who is already:
- Leading architecture
- Influencing several engineers
- Reviewing critical work
- Owning production behaviour
- Taking responsibility beyond individual features
can absolutely be relevant.
📈 Why join Script Assist?
At a very large organisation, a Staff Engineer may own one layer or one subsystem of a much bigger machine.
At Script Assist, you can have meaningful influence across a significant part of the product.
You will help determine:
- How major areas are designed
- How the platform handles customer variation
- How engineers structure new functionality
- How code quality is maintained
- How technical debt is reduced
- How production issues are prevented
- How engineering scales as the company grows
You will remain hands-on.
But the objective is not simply to become the person who can write the most difficult code.
- The objective is to make a substantial part of the platform — and the engineers responsible for it — better because of your technical leadership.
Click on Apply to know more.