Custom software development for complex industry workflows.
AI, Software + SolutionsWhen critical work depends on disconnected tools, repeated workarounds or a process nobody has resolved, the answer starts with understanding why. OBELISK brings software engineering, industry expertise and applied research together to develop the appropriate application, integration and working process.
Chennai, India · Global deliveryStart with the problem behind the software request.
For process owners and technology leaders working around disconnected applications, repeated data entry and hard-to-trace decisions.
A request for another application often begins with a deeper operating problem: information arrives late, approvals lose their owner, the same data is entered repeatedly, or existing systems cannot exchange what teams need. We trace those problems through the people, decisions and interfaces involved before agreeing what should change.
Choose the intervention that the work needs.
The appropriate outcome may be a focused web application, an integration, an improvement to an existing system, or a redesigned process supported by software. Discovery establishes the delivery boundary, required expertise and acceptance criteria. A new build is a decision to justify, not the starting assumption.
Operating challenges
- Disconnected information
- Investigate where records diverge, which source is authoritative and how an exchange could be checked.
- Manual or unclear handoffs
- Map who receives a request, what makes it complete and who is accountable when it is returned.
- A workflow the existing system cannot support
- Review configuration, interfaces and constraints before deciding whether to extend, integrate or replace anything.
- Request capture
Record the need and source information.
- Validation
Check completeness and agreed rules.
- Assigned action
Give the next action a named owner.
- Review
Record the authorised decision.
- Outcome
Keep the result and unresolved items visible.
A failed validation or returned review goes back to the assigned owner for correction and recheck.
Make the output and its acceptance visible.
Agree the release boundary, what stays outside it, the inputs each team provides and who reviews the result. These five modules describe the existing web-software offer; the engagement selects the work actually needed.
Product discovery
Discovery produces a current-state workflow, user roles, business rules, dependencies and a prioritised delivery brief. It identifies the decision the first release must support.
Inputs and review
- Useful inputs
- Available process notes, representative redacted records, stakeholder roles and desired outcomes. A completed specification is not required.
- Review and acceptance
- Client decision owners review the problem definition, priorities, exclusions and proposed acceptance criteria.
UX and solution design
UX and application design connect task-based screens, data structures, access boundaries and exception paths in a reviewable prototype and architecture outline.
Inputs and review
- Useful inputs
- User scenarios, accessibility needs, data ownership and known system constraints.
- Review and acceptance
- Relevant users and technical reviewers walk through normal, rejected and returned-for-correction scenarios before implementation.
Web application development
Web application engineering builds the agreed browser-based operational tool, portal or reporting workflow in reviewable increments. Each increment connects back to an accepted requirement.
Inputs and review
- Useful inputs
- An agreed release scope, source-data rules, development access and available client reviewers.
- Review and acceptance
- The product owner checks working scenarios, permissions, validation and the agreed browser behaviour; outstanding issues remain visible.
API integration
APIs and system integration define interface contracts, mappings, validation, authentication, error handling and exchange ownership. Feasibility depends on what each existing platform permits.
Inputs and review
- Useful inputs
- Interface documentation, authorised test access, sample payloads and named source-system owners.
- Review and acceptance
- Technical reviewers check normal exchanges, duplicate handling, retries, rejected data and reconciliation against the agreed cases.
Testing and deployment support
Testing, deployment and handover assemble acceptance evidence, environment configuration, release notes and operating guidance for the receiving team. Support after release is agreed separately.
Inputs and review
- Useful inputs
- Acceptance cases, authorised deployment access, environment requirements and a named receiving owner.
- Review and acceptance
- Review the release decision, remaining issues, deployment and rollback arrangements, access transfer and handover responsibilities.
Research the unmet. Resolve the root cause.
Our R&D department focuses on industry needs that existing approaches have left unaddressed. Where the problem calls for investigation, we examine root causes, test possible interventions and refine the solution and supporting process through practical validation.
Use a bounded investigation when the cause, interface feasibility or appropriate intervention is still uncertain. A clear, routine development brief can proceed through ordinary discovery and delivery without a separate research engagement.
Explore the R&D approach- Problem definition
- Record the people affected, the unmet need and what would count as an improvement.
- Assumptions and prototype findings
- Test the uncertain part with approved inputs; record what worked, what failed and what remains unresolved.
- Acceptance evidence and next decision
- Review findings with the decision owner before agreeing implementation, further investigation or a stop.
A review point at every delivery stage.
Understand the operating problem
- Output to agree
- Problem definition, stakeholders and intended outcome.
- Client decision point
- Client decision owners confirm which problem is worth addressing.
Diagnose causes and constraints
- Output to agree
- Current-state workflow, dependencies, access needs and identified risks.
- Client decision point
- Process and system owners review the assumptions and investigation boundary.
Design the solution and process
- Output to agree
- Prototype, architecture decisions, exclusions and proposed delivery scope.
- Client decision point
- Relevant users and technical owners agree the direction and acceptance criteria.
Build and review
- Output to agree
- Working increments, feedback, issue records and controlled changes.
- Client decision point
- The product owner reviews behaviour and approves the impact of proposed scope changes.
Validate and release
- Output to agree
- Reviewed acceptance cases, open issues and a recorded release decision.
- Client decision point
- Appointed reviewers and the receiving owner agree release readiness and any conditions.
Hand over and evolve
- Output to agree
- Documentation, access transfer, ownership and a prioritised future-work list.
- Client decision point
- The receiving team accepts handover; maintenance or later releases need a separate agreement.
Scope, access dependencies, risks and decisions are recorded in agreed project documents. A proposed change includes its impact on outputs, effort and acceptance before approval. Review cadence and reporting formats are agreed; no client portal or real-time dashboard is implied.
How we engage
Discovery and prototype, minimum viable product, then roadmap-based product development.
Our delivery processTechnology context
- React
- .NET
- Python
- Azure
- AWS
- React
- Browser-based user interfaces. Browser support and accessibility requirements belong in the release brief.
- .NET, Python and APIs
- Application services and approved integrations. The architecture follows data needs, existing systems and the team that will maintain it.
- Azure or AWS
- A possible application deployment environment. Hosting, access, costs and operational responsibilities require an environment-specific decision.
Tools and licences are agreed for your environment. Names indicate technology context, not vendor affiliation.
Engineered for dependable operation.
A useful application needs more than working screens. The agreed architecture and delivery scope should address how the system behaves when access is refused, information is invalid or an integration fails—and who owns its operation.
Permissions and validation
Define who may see or change each record. Review invalid inputs, denied actions and sensitive transitions against agreed cases.
Integration failure handling
Agree timeout, retry, duplicate and reconciliation behaviour with source-system owners. Make unresolved exchanges visible to the responsible operator.
Operating visibility
Agree which events, errors and health signals are needed, who reviews them and what information must not be logged. Monitoring tools are chosen for the approved environment.
Recovery and release control
Define appropriate backup, restore, rollback and recovery checks where included in scope. Recovery expectations depend on the environment and an agreed operating plan.
Maintainability and ownership
Review architecture decisions, configuration, dependencies and documentation with the receiving team. Maintenance coverage and response commitments require a separate support scope.
Replace a critical spreadsheet with a focused web workflow.
- The challenge
- When spreadsheets, email and disconnected applications obscure the work, define the operational problem and build a focused software workflow around it.
- Root cause to investigate
- Different teams may maintain separate records because ownership, system interfaces and shared identifiers are not defined.
- Expertise applied
- User research, workflow design, web application engineering and approved API integration.
- Proposed intervention
- Map a request from intake to completion, define one authoritative record and build the smallest useful workflow around existing systems.
- Validation method
- Ask representative users to complete agreed normal and exception scenarios; check permissions, data reconciliation and recovery from failed exchanges.
- Intended improvement
- Clearer status, fewer repeated entries and a maintainable workflow; measure the change after validation.
| Release question | Evidence to agree |
|---|---|
| Does the workflow meet the brief? | Reviewed acceptance cases and remaining issues |
| Can the receiving team operate it? | Environment configuration, deployment notes and named owner |
| What happens next? | Prioritised backlog and separately agreed support arrangements |
Match the engagement to what is known.
User roles, workflow complexity, migration quality, interface readiness, security/access requirements, reviewer availability and hosting constraints shape scope, effort and sequencing. Fees and timelines follow an agreed brief.
Agree accountability before delivery.
Agree repository access, source-code ownership, third-party licences, documentation and handover rights in the contract before build. Identify who approves changes and accepts release. Support and maintenance are separate scope decisions, not an automatic promise after launch.
How scope, decisions and handover stay visible
These practices form the delivery agreement for the engagement. The outputs, review cadence and support boundaries are confirmed during scoping.
- A shared delivery brief
- Agree scope, assumptions, exclusions, dependencies and who can make each decision.
- A mapped workflow
- Review the current process and proposed changes with the people who use and own the work.
- Reviewable milestones
- Agree outputs, acceptance criteria and the client decision needed at each milestone.
- Visible risks and decisions
- Agree a progress-review cadence and record blockers, risks and decisions with named owners.
- Controlled changes
- Document proposed changes, their implications and approvals before changing the delivery baseline.
- An owned handover
- Agree documentation, operating responsibilities, access transfer and any support arrangements before transition.
Engineered for resilience.
Engineered for resilience means making failure and recovery part of the design. Where included in scope, we review architecture, controlled access, validation, failure handling, recovery planning, monitoring and maintainability. The objective is dependable operation within agreed conditions, with limitations and residual risks recorded.
Questions before commissioning software.
How do you determine whether we need new software?
Map the operating problem, current workflow and existing-system constraints first. The intervention may be process change, configuration, integration or a focused application. The build boundary follows the evidence.
Can our existing systems stay in place?
Where appropriate. Review available interfaces, permissions, documentation, data quality and validation options. An integration depends on authorised access and the source platform’s actual capabilities.
What do we need to provide at the beginning?
Bring available process notes, users and decision owners, system information and desired outcomes. Redacted examples or sketches are useful; incomplete information is fine and a completed specification is not required for an initial conversation.
How are requirements and changes reviewed?
Agree priorities, exclusions, acceptance criteria and decision owners in the brief. Review proposed changes with their impact on scope, dependencies and acceptance before approval; record decisions in the agreed project documentation.
What evidence supports release acceptance?
Agree representative user scenarios and relevant permission, validation, integration and failure cases. Review results, unresolved issues and operating readiness with appointed owners before the release decision.
Who owns the source code and documentation?
Ownership, repository access, licences and handover rights are specified in the engagement terms. Rights to third-party software do not automatically transfer with custom code; confirm access and permitted use before delivery.
How are timelines and fees determined?
Workflow breadth, user roles, integrations, migration, validation, access and the intended environment affect effort. Scope, dependencies and acceptance requirements are reviewed before fees or delivery dates are agreed.
What is included after launch?
Agree the hosting owner, issue triage, maintenance tasks, change process, coverage and response expectations separately. Handover documentation does not by itself establish an ongoing support service or availability commitment.
When would R&D be relevant?
When the cause, feasibility or suitable intervention remains unclear, a bounded investigation or prototype can test the assumptions. Routine work with a clear brief does not automatically require a separate research engagement.
Can we start with a prototype or a smaller release?
Yes. Discovery and a prototype can clarify user tasks and constraints before agreeing a first release. Prototype findings inform the next decision; a demonstration alone does not prove production readiness.
Tell us where the work breaks down.
Share the process, the people and the systems involved—and what remains difficult today. We will help define the problem and the appropriate next step.
Discuss your software challenge