Python Developer

Location: Ahmedabad (on-site)

Type: Full time

Experience: 1- 5 years To Apply fill in the Microsoft form: https://forms.cloud.microsoft/r/XktwFdpf2w

__________________________________________________

About the Role

We are a proprietary quantitative trading firm focused on Indian and global equity, derivatives,

and cryptocurrency markets. Our research and trading depend on data being correct, complete,

reproducible and available on time. This role owns the programs and processes that make that possible.

You will build and maintain Python programs that collect data from broker and exchange APIs,

third-party market-data vendors, public sources and internal files, clean and reconcile it, and manage storage in ClickHouse, PostgreSQL and Parquet. You will preserve point-in-time versions so research can reproduce the information available on a historical date, and keep scheduled and continuously running processes reliable on Linux.

Strong, hands-on Python programming is essential . you must be able to write, debug and maintain the underlying code yourself. Experience limited to configuring managed platforms,

assembling graphical workflows or writing SQL in database clients is insufficient. Financial-

market knowledge is preferred.

Responsibilities -

Data ingestion. Build and maintain Python programs integrating REST APIs and WebSocket feeds from brokers, exchanges and data vendors, along with websites and structured files.

Handle scheduled downloads, continuous collection, pagination, rate limits, retries,

reconnections and recovery of missing data.

Vendor and broker API management. Handle authentication and API keys, token and session lifecycles, permissions and entitlements, subscription limits and IP restrictions. Work around undocumented behaviour and keep integrations running when a provider changes its interface or access rules without notice.

Cleaning and reconciliation. Resolve differences in schemas, identifiers, symbol conventions, timestamps and timezones using pandas and NumPy. Maintain instrument mappings across sources, and investigate inconsistent prices, corporate-action adjustments,

missing observations and source disagreements.

Storage design. Work with ClickHouse, PostgreSQL, Parquet and CSV through connectors such as psycopg2, asyncpg, SQLAlchemy, clickhouse-connect and pyarrow. Choose schemas, keys, partitions, indexes and query patterns suited to large time-series datasets,

and manage memory and performance as volumes grow.

Point-in-time versioning. Retain original values and later revisions with the timestamps and source information needed to establish when each became available, supporting retrieval of both the latest data and the information available at a historical decision time.





Backfills and reprocessing. Recover historical gaps and regenerate datasets when source data or processing logic changes, without breaking reproducibility or conflicting with ongoing updates.

Data quality and monitoring. Detect duplicates, stale feeds, missing timestamps,

unexpected values and incomplete responses, and make failures visible through useful logs,

alerts and status information.

Internal tools. Build Python utilities, scripts and simple graphical interfaces for recurring internal tasks that team members need to run without writing code, packaged as standalone applications where useful. Requirements often arrive informally and partially specified, so the work includes clarifying what is actually needed.

Data-access interface. Maintain a consistent Python interface giving research and trading systems a standard way to retrieve live and historical data, reducing duplicated cleaning logic.

Reliability on Linux. Manage scheduling, process supervision, structured logging and log rotation. Diagnose failures and ensure retries, restarts and reconnections do not silently lose or duplicate data.

Maintenance and collaboration. Investigate unfamiliar programs, resolve bugs and performance problems, translate requirements from quant team members into maintainable programs, and document procedures, dependencies, provider behaviour and known issues.

What We Expect

Relevant professional Python experience building and maintaining substantial programs used in a working environment.

Strong core Python. Data structures, object behaviour, iterators, generators, exceptions,

context managers, modules, and appropriate use of functions and classes. You must be able to independently write, explain, debug and maintain code.

Command of the Python ecosystem. pandas and NumPy for real processing, the standard library (datetime, itertools, functools, logging, pathlib, json, typing, asyncio,

multiprocessing, threading, concurrent.futures), and common libraries for HTTP,

WebSocket, parsing, validation and testing, with an understanding of their limitations.

Third-party API integration. Working against interfaces you do not control: authenticated and rate-limited APIs, streaming connections, paginated historical endpoints, incomplete documentation, credential and session expiry, provider outages and breaking changes.





Database and SQL ability. Programmatic access from Python including parameterised queries, transactions, bulk inserts and connection handling, plus joins, analytical queries and investigating slow or incorrect results.

Real dataset experience. Inconsistent schemas, missing values, duplicates and unexpected upstream changes, with efficient use of vectorised operations, dtypes, chunked reads and columnar formats where data does not fit in memory.

Concurrency and performance judgment. When to use threads, async I/O or multiprocessing, how the GIL affects the workload, and how to control memory and shared-

state problems.

Operational understanding. Timeouts, partial responses, rate limits, idempotency and safe recovery, including what happens when a process stops halfway through its work.

Linux confidence. Inspecting processes and logs, managing scheduled jobs, diagnosing resource issues and running programs outside an interactive notebook.

Version control and project practices. Git for tracking changes, branching and history, plus proper project structure, configuration and credentials kept out of code, virtual environments and pinned dependencies.

Validation and debugging habits. Checking data correctness as well as whether a program runs, using tests and reconciliation checks, and being able to explain how you verified a fix.

Preferred Experience

Financial-market data, instruments, trading sessions, corporate actions and market conventions.

Broker, exchange or market-data vendor APIs, including historical downloads and live feeds.

WebSocket collectors, streaming ingestion, out-of-order events and gap recovery.

ClickHouse, PostgreSQL, Parquet and large-scale time-series storage.

Point-in-time datasets and internal Python libraries used by other team members.

Internal tools or interfaces built for non-developers, including packaged applications.

Profiling, memory optimisation and libraries such as polars, numba or Cython where justified.

What This Role Is Not A web-development role. Websites, frontend features, CRUD applications and standard

Django/FastAPI endpoints are not the work.

A BI or reporting role. Dashboards, visualisation tools and Excel reporting are not the deliverables.

A platform-configuration role. Managed ETL platforms, graphical workflows and notebook services do not substitute for implementing the logic in Python.

A SQL-only or database-operator role. SQL matters, but the position requires ownership of the Python programs that acquire, validate, transform and deliver the data.

A cloud architecture or DevOps role. Linux operations support the systems you build;

infrastructure and deployment tooling are not the focus.

📌 Python Developer (Ahmedabad)
🏢 Clear Quant
📍 Ahmedabad