ciphers™ is an independent software and AI lab based in Mumbai. We research consequential Indian workflows and turn the strongest product theses into focused experiments.
Our current experiment is Startaflo™, a proposed founder operating system for the administrative life of an Indian company. Startaflo is currently at the public-waitlist stage and is not publicly released.
We are a small team. That makes judgement, product thinking, written communication, and care for the whole system as important as technical execution.
We are looking for a Full-Stack Engineer who is comfortable owning software across the entire stack.
You will work across frontend applications, backend services, APIs, data modelling, databases, background processing, cloud infrastructure, integrations, observability, and carefully bounded AI capabilities.
You will be expected to understand how the pieces fit together rather than treating frontend, backend, database, and infrastructure as separate worlds.
The role involves building production systems from the ground up, making architectural decisions, modelling real-world workflows, and taking features from an idea or ambiguous requirement to a reliable production implementation.
This is not a role for simply implementing pre-written tickets or assembling screens from settled specifications.
The useful specification often emerges through research, prototypes, technical exploration, and close reasoning with the team.
Our primary stack includes:
TypeScript · React · Next.js · Node.js · PostgreSQL · AWS
You will work across technologies such as:
- TypeScript
- React
- Next.js
- Node.js
- PostgreSQL
- REST APIs
- Relational data modelling
- Background jobs and workers
- Queues and asynchronous processing
- AWS infrastructure
- Cloud deployment and CI/CD
- Object storage
- Authentication and authorization
- Third-party APIs and integrations
- Logging, monitoring, and observability
- AI / LLM systems
The exact implementation will evolve as the product evolves. Strong engineering fundamentals matter more to us than having used every tool listed above.
Own features end to end — from understanding the requirement and modelling the domain to designing the database, building APIs and backend logic, implementing the frontend, testing the system, deploying it, and monitoring it in production.
You should be comfortable moving between:
UI → API → business logic → database → background processing → infrastructure
without treating those boundaries as someone else's problem.
Design and evolve relational data models that accurately represent real-world workflows.
This includes thinking about:
- Entities and relationships
- Normalisation and denormalisation
- Constraints and invariants
- Foreign keys
- Indexes
- Transactions
- Concurrency
- Data integrity
- Schema evolution
- Audit history
- State transitions
- Permissions and ownership
- Performance
You should be able to explain why a model is structured the way it is, not simply create tables that make the current feature work.
Build reliable backend systems and APIs using Node.js and TypeScript.
You will work on:
- API design
- Business logic
- Validation
- Authentication and authorization
- Transactional workflows
- Error handling
- Idempotency
- Background processing
- Third-party integrations
- Rate limiting
- Reliability and failure recovery
The backend should remain understandable, testable, and predictable as the product grows.
Build polished, accessible interfaces using React and Next.js.
You will care about:
- Component architecture
- Application state
- Server/client boundaries
- Forms and validation
- Loading and error states
- Accessibility
- Performance
- Responsive behaviour
- Clear information architecture
- Consistent product interactions
The goal is not simply to make an interface look good, but to make complicated workflows understandable.
Work directly with AWS and help own the infrastructure that runs the product.
Depending on the system, this may involve services such as:
- EC2
- ECS
- Lambda
- RDS / PostgreSQL
- S3
- CloudFront
- Route 53
- IAM
- CloudWatch
- SQS
- SNS
- EventBridge
You should understand how applications are deployed, secured, monitored, scaled, and recovered in production.
You do not need to be a dedicated DevOps engineer, but you should be capable of owning the engineering lifecycle beyond localhost.
Use AI where it provides a clear, measurable benefit.
You will help determine:
- Where AI is appropriate
- Where deterministic logic is required
- How AI outputs should be evaluated
- How failures should be handled
- What information must be preserved
- How probabilistic behaviour should be bounded inside production workflows
We are interested in AI that improves a real workflow, not AI added simply because it is fashionable.
Write tests, review code, investigate failures, improve observability, and maintain the systems you ship.
You will be expected to think about:
- Reliability
- Security
- Performance
- Monitoring
- Debuggability
- Deployment safety
- Rollbacks
- Failure recovery
- Operational tooling
Shipping is only part of the job. Keeping the software healthy is part of the job too.
We are looking for someone with strong full-stack fundamentals and real production experience.
You should be comfortable with:
- Strong TypeScript fundamentals
- React
- Next.js
- Modern frontend architecture
- Accessible and responsive interfaces
- State management and data fetching
- Form-heavy and workflow-driven interfaces
- Node.js
- TypeScript
- API design
- Business logic
- Authentication and authorization
- Validation
- Error handling
- Asynchronous processing
- Third-party integrations
- PostgreSQL or another serious relational database
- Relational data modelling
- Schema design
- Indexing
- Transactions
- Query optimisation
- Data integrity
- Migration strategies
- AWS
- Linux fundamentals
- Application deployment
- CI/CD
- Networking fundamentals
- Environment and secrets management
- Logging and monitoring
- Production debugging
You should also demonstrate:
- Experience building and maintaining production software
- Strong understanding of software architecture and system boundaries
- Good judgement around security, reliability, performance, and maintainability
- Ability to reason about edge cases and failure modes
- Ability to work independently without losing product context
- Ability to understand unfamiliar domains quickly
- Clear written and verbal communication
- Willingness to challenge assumptions and change your mind when evidence changes
We care much more about depth, judgement, ownership, and learning ability than a perfect technology checklist.
Experience with the following is a strong plus:
- AWS architecture and cost optimisation
- Docker and containerised deployments
- ECS, EC2, Lambda, RDS, S3, SQS, CloudWatch, or equivalent AWS services
- Redis
- Background workers and job queues
- Event-driven systems
- Distributed systems concepts
- Advanced PostgreSQL
- Database performance optimisation
- Multi-tenant systems
- RBAC and complex permission models
- Audit trails
- Document-heavy workflows
- Multi-step B2B workflows
- Compliance or administrative software
- Software built for Indian businesses
- LLM applications
- Retrieval and evaluation systems
- AI agents and tool calling
- Open-source contributions
- Technical writing
- A serious side project or product you have built yourself
In your first months, success means understanding the product and domain well enough to make independent technical decisions without losing important context.
Given an ambiguous workflow, you should be able to determine:
What are the actual entities involved?
What states can they exist in?
What transitions are valid?
What belongs in the database?
What needs to be transactional?
What happens if an external service fails?
What should be retried?
What must be idempotent?
What should be audited?
Which parts can use AI?
Which parts must remain deterministic?
What happens when users do something unexpected?
Then you should be able to turn those answers into a coherent, production-quality implementation.
Over time, you will help build engineering practices that allow the product to scale without turning a small company into an architecture exercise.
The goal is software that is:
Legible. Secure. Reliable. Observable. Performant. Straightforward to change.
We prefer evidence to theatre and thoughtful urgency to performative urgency.
We value engineers who think beyond their immediate task and care about the complete product.
That includes:
- Product language
- User experience
- Accessibility
- Security
- Data integrity
- Operational quality
- Infrastructure
- Failure recovery
- Performance
- The details users should never have to notice
We expect engineers to take ownership, ask good questions, and push back when something does not make sense.
You will probably enjoy this role if you like:
- Building from first principles
- Owning features end to end
- Working across the entire stack
- Designing systems, not just implementing screens
- Thinking deeply about data models
- Solving ambiguous problems
- Learning new domains
- Shipping production software
- Improving systems after they ship
- Understanding the "why" behind the requirements
You may not enjoy this role if you prefer highly compartmentalised responsibilities, strictly predefined specifications, or working exclusively within one technical layer.
Startaflo is being built around a simple thesis:
Founders should spend less time managing the administrative machinery around their company and more time building the company itself.
The workflows involved are messy, consequential, and often poorly represented by traditional software.
The engineering challenge is therefore not simply to build another dashboard.
It is to turn complicated real-world operations into software that people can trust.
You will have an opportunity to influence not only how we build the system, but also what the system should be.
