Applied expertise · Software engineering · Industry solutions

Custom software development for complex industry workflows.

AI, Software + Solutions

When 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 delivery
Background images change every six seconds. Hover pauses rotation. Keyboard focus or manual selection pauses it until Play. Left and right arrows work within the controls. Reduced motion disables autoplay.
The opportunity

Start 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-to-outcome workflow
  1. Request capture

    Record the need and source information.

  2. Validation

    Check completeness and agreed rules.

  3. Assigned action

    Give the next action a named owner.

  4. Review

    Record the authorised decision.

  5. Outcome

    Keep the result and unresolved items visible.

A failed validation or returned review goes back to the assigned owner for correction and recheck.

Delivery scope

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.

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
Our approach

A review point at every delivery stage.

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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 process

Technology 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.
Explore delivery approaches
A release-readiness checklist.
Release questionEvidence 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.

Discovery and prototype
A bounded problem definition, investigated assumptions, user scenarios and a reviewed direction. The output informs a build decision; it is not automatically a production application.
First-release delivery
An agreed priority web workflow and selected interfaces, delivered through reviewable increments and acceptance. Dependencies, exclusions and release conditions belong in the delivery brief.
Ongoing development
Later changes organised around an owned backlog, change review and agreed release responsibilities. Hosting, maintenance, coverage and response arrangements are defined explicitly.
Before we begin

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