Design that is accountable to an outcome
Beautiful is table stakes. We design interfaces that reduce the time to complete a task, raise the rate at which people finish it, and hold together as a system when twenty more screens arrive next year.
There is a version of design that produces gorgeous artboards and a project that stalls in build. There is another version that produces something usable but forgettable. The work we care about sits between them: interfaces that are visually confident and structurally sound, drawn with enough understanding of the underlying system that engineering receives something buildable rather than aspirational.
Our design practice grew out of an engineering practice, which shapes everything about how we work. We design in components from the first week. We name things the way the code will name them. We specify states — empty, loading, error, partial, offline, too-much-data — because those are the states real users actually encounter, and a design that only shows the happy path is a mood board rather than a specification.
We work across three kinds of problem. Marketing and brand experiences, where the job is to hold attention and earn a decision. Product and SaaS interfaces, where the job is to make complex work feel controllable. And internal tools — the dispatch screens, inspection forms and approval queues that thirty people use for six hours a day — where a fifteen-second saving per transaction is worth more than any amount of visual flourish.
In every case we start with the same question: what does success look like in a number, and what is currently preventing it?
Research proportionate to the risk
Research does not have to mean a twelve-week ethnographic study. It has to mean not designing from assumption. For a marketing site the right research may be four customer interviews, a review of the sales team's most-repeated objections, and a session-recording analysis of the current site. For a plant-floor application it means standing on the plant floor, watching someone use the existing system with gloves on in poor light, and understanding why they keep a paper notebook alongside it.
We calibrate depth to consequence. Redesigning a checkout that processes ₹4 crore a year justifies a serious study. Refreshing an about page does not. What we refuse to do is skip the step entirely and then present opinions as findings.
Everything we learn goes into a short, readable insight document — usually eight to twelve pages — that becomes the shared reference for the project. It is the artefact that settles arguments later, because "the users told us" is only useful when there is a record of what they said.
In practice
Every engagement starts with a conversation, not a proposal template.
Thirty minutes with a senior engineer. You leave with an architecture sketch and an honest cost range, whether or not you hire us.
Storyboards before screens
Every page we design has a narrative structure before it has a layout. We storyboard the sequence a visitor moves through: the tension they arrive with, the insight that reframes it, the plan we propose, the proof that we can execute it, and the invitation to act. This is not decoration — it determines what appears at which scroll depth and what gets cut.
Storyboarding early is also the cheapest place to discover that a page has no argument. A great many websites fail not because the design is poor but because the page never makes a case; it lists features and hopes. Working the narrative out in low fidelity, with a client in the room, exposes that in an afternoon rather than in month three.
From storyboard we go to mobile-width wireframes, then to visual direction on two or three key templates. The rest of the site is composed from the resulting system, which is what keeps a sixty-page estate coherent and affordable.
Design systems that survive the second year
A design system is not a colour palette in a Figma file. It is a set of decisions with enough rigour that a designer who joins next year, or an engineer who never spoke to the original designer, makes the same choice you would have made.
Ours are built in layers. Foundation tokens — colour, type scale, spacing, radius, shadow, motion durations — defined once and referenced everywhere, with semantic aliases so that "surface-raised" and "text-muted" mean something rather than a hex code being pasted around. Then primitives: button, field, card, tag, table, dialog, each with every state drawn and named. Then patterns: forms, empty states, data-dense layouts, pricing tables, navigation. Then page templates assembled from patterns.
Critically, the same names exist in the code. When a designer says "use the raised card with the brand accent bar", an engineer knows exactly which component that is because it is called the same thing in the repository. That single alignment eliminates most of the friction people describe as "handoff problems".
Accessibility is a design responsibility, not a QA finding
Contrast is verified in the palette, not after. Focus states are drawn for every interactive component. Touch targets are sized in the spec. Error messages are written by the designer. If accessibility only appears in a testing report, it was designed wrong.
Prototypes that answer real questions
We prototype the interactions that carry risk, not the ones that are fun to animate. If a multi-step form is the crux of the product, that gets a working prototype with real validation behaviour and error handling. If a data table needs to support filtering, sorting and bulk selection on a 13-inch laptop, that gets built and tested with plausible data volumes, because tables that look elegant with six rows fall apart with six hundred.
For consumer-facing work we test prototypes with five to eight participants from the actual audience. Five is enough to find the majority of severe usability problems, and severe problems are what we are hunting. Findings come back as a ranked list with video clips attached, which is far more persuasive in a stakeholder meeting than a written summary.
Every engagement starts with a conversation, not a proposal template.
Thirty minutes with a senior engineer. You leave with an architecture sketch and an honest cost range, whether or not you hire us.
Motion with a purpose
Motion earns its place when it explains something: where a panel came from, that a list is being filtered rather than replaced, that a long operation is progressing, that an action succeeded. Motion that exists to be noticed is a cost — it delays interaction, it distracts, and it disproportionately affects people with vestibular sensitivities.
We specify motion as part of the system: durations on a scale, easing curves chosen for the kind of movement, and a documented rule that anything above 200 milliseconds must be interruptible. Every animation respects the reduced-motion preference, which is a two-line implementation detail that a surprising number of otherwise-good sites get wrong.
In practice
Every engagement starts with a conversation, not a proposal template.
Thirty minutes with a senior engineer. You leave with an architecture sketch and an honest cost range, whether or not you hire us.
Design for data-dense and industrial interfaces
A large part of our work is not consumer-facing at all. It is a plant supervisor entering shift data at 6 AM, a dispatch clerk allocating trucks, a credit officer reviewing forty applications. These interfaces have different rules: density beats whitespace, keyboard beats mouse, the fastest path beats the prettiest one, and the screen must remain readable on a five-year-old monitor in a bright room.
We design these with the operator in the room. We time the current process, design to reduce that time, and measure again after rollout. On one dispatch system the redesign reduced average allocation time from 3 minutes 40 seconds to 1 minute 5 seconds, which across a shift is close to two hours of recovered capacity — a result no visual refresh alone would have produced.
“They spent two days on our shop floor before drawing anything. The screens they came back with had fields in the order we actually fill them, which no vendor had ever managed before.”
What is actually included in ui/ux & product design
Each of these is something we have shipped and still support in production — not a list of things we could do if asked.
Product and SaaS design
Information architecture, flows, dense data interfaces, onboarding and settings design for complex products.
Marketing and brand experiences
Narrative-led long-form pages, campaign microsites and conversion-focused landing pages.
Design systems
Token architecture, component libraries, documentation and governance so the system stays alive.
User research
Interviews, contextual enquiry, usability testing, analytics review and task-time measurement.
Prototyping
Interactive prototypes for the risky flows, tested with real users before engineering commits.
Illustration and iconography
Custom technical illustration and icon sets drawn for your domain rather than pulled from a stock library.
Accessibility design
WCAG 2.2 AA built into the palette, components and content patterns from the start.
Design-to-code delivery
Components named identically in Figma and the repository, with tokens exported programmatically.
The stack we actually use for this
Chosen for what your team can maintain in three years, not for what looks impressive in a proposal.
Design
- Figma
- Figma Variables
- FigJam
- Rive
- Adobe Illustrator
Research
- Maze
- Hotjar
- Clarity
- Dovetail
- GA4
Handoff
- Storybook
- Design tokens (JSON)
- Tailwind config
- Chromatic
Motion
- Framer Motion
- CSS transitions
- Lottie
- SVG SMIL
From first conversation to something in production
Two-week slices, a demo you can share every alternate Friday, and no phase where you are waiting without seeing progress.
Frame the problem
Success metric, constraints, audience and the specific behaviour we need to change.
Research
Proportionate to risk — interviews, observation, analytics — condensed into a short insight document.
Structure
Information architecture, page narratives and storyboards agreed before any visual work.
System and direction
Tokens, primitives and two or three key templates at final fidelity.
Prototype and test
Working prototypes of the risky flows, tested and revised with evidence.
Deliver and support build
Documented components, specs for every state, and designers available through the build.
Everything hands over. No lock-in, ever.
Source code in your Git organisation, infrastructure in your cloud account, domains in your name and documentation written for the next team rather than for us. If you part ways with us in year three, a competent engineer should be able to take over in a fortnight.
Deliverables checklist
- Insight document from research
- Sitemap, user flows and page storyboards
- Figma design system with variables and documented components
- Final designs at mobile, tablet and desktop widths
- Every state specified: empty, loading, error, partial, success
- Interactive prototypes for the critical journeys
- Accessibility annotations and contrast verification
- Exported design tokens ready for the codebase
What this typically costs
Real ranges from real projects. The variable is almost always scope and integration count — the calculator will get you closer in two minutes.
Design sprint
₹1,10,000 – ₹2,20,000
One product decision resolved in two weeks with a tested prototype.
- Research
- Storyboards
- Prototype
- User testing
- Recommendation
Site or product design
₹2,80,000 – ₹8,00,000
Full design of a site or product surface with a system behind it.
- Research and IA
- Design system
- All templates and states
- Prototypes
- Build support
Design system
₹4,50,000 upwards
Multi-product organisations needing consistency and governance.
- Token architecture
- Component library
- Documentation site
- Governance model
- Team training
All figures exclude GST. Fixed-price options available on defined scope. Build your own estimate →
The questions clients actually ask
Including the ones where the honest answer is that you may not need us. If your question is not here, call +91 70033 91355 — you will speak to an engineer, not a call handler.
Yes, and a fair share of our design work is delivered to a client's own engineering team or another agency. We deliver a documented system, specs for every state, and exported tokens, and we stay available through the build for questions — because a design handed over and abandoned always degrades in implementation.
By naming things identically, exporting tokens programmatically rather than transcribing hex codes, and running visual regression tests on the component library. We also do a design QA pass before launch where a designer reviews the real site on real devices against the specification and files differences as bugs. It typically finds twenty to forty small deviations that would otherwise ship.
No. Every layout is drawn for the specific content and argument of that page. We do use AI in the process — for early exploration, for content structuring, for generating variations we then judge — but nothing reaches a client without a designer having made the composition decisions. Template-driven sites are recognisable within seconds, and that recognisability is itself a credibility cost.
We draw custom technical illustrations in SVG — architecture diagrams, process flows, plant schematics, data pipelines — because generic stock illustration says nothing about your business and the current crop of AI-generated art is instantly identifiable. Hand-built SVG also loads in kilobytes, scales perfectly on any screen, and can be animated meaningfully. Where photography is needed we art-direct a shoot or curate properly licensed images.
We do not count revisions, because counting them makes clients hoard feedback and makes designers defensive. We work in review cycles at defined stages — structure, direction, detail — and iterate within each until it is right. What we do fix is scope: adding six new page types halfway through is a change of scope, not a revision, and we will quote it separately and transparently.
Certainly. We treat established brand assets as constraints to design within, and we will flag honestly where a guideline creates a genuine usability problem — a brand colour that fails contrast on white, for instance — with a proposed digital-specific extension rather than a demand to change the brand.
Why being local to you matters here
Design maturity in Kolkata has risen sharply in the past five years, but most local product teams still lack an in-house design system, which means every new screen re-litigates decisions that should have been settled once. We build that foundation and train the team to extend it — several of our clients now run their own systems with us only reviewing quarterly.
For UI/UX and product design in Kolkata, call +91 70033 91355 or WhatsApp us. We are happy to run a free one-hour teardown of your current interface before you commit to anything.
Services that pair with this
View everythingTell us what is slowing your business down.
A 30-minute call with a senior engineer — not a salesperson. You leave with an architecture sketch and an honest cost range, whether or not you hire us.
Direct line
+91 70033 91355Mon–Sat · 9:30 AM – 7:30 PM IST · Sealdah, Kolkata