Lead Engineer

Corporate Solutions Tech; Jacksonville (FL); On-site; USD 130,000 - 160,000; Full time

Job summary

Corporate Solutions Tech in Jacksonville, FL seeks a senior hands-on engineer to own the technical integrity of a core backend platform. You will build, not merely advise, delivering secure, high-quality code on time under architectural direction and leading a small specialist team.

This role emphasizes event-driven architectures, domain modeling, multi-tenant security, AI-assisted development, robust testing, and Python-based, serverless-first cloud-native practices.

Qualifications

• 8–12 years hands-on, recently built and delivered work
• Event-driven architecture design and build (event sourcing/CQRS)
• Strong domain-modeling judgment to spot new patterns
• Multi-tenant security with server-side isolation and data encryption in transit and at rest
• Delivery leadership with accountability, execution focus, and clear communication
• Fluent in AI-assisted development - directing and verifying AI-generated code and tests
• Test strategy and verification judgment to ensure genuine coverage
• Strong Python proficiency
• Relational-database and read-model/projection design experience
• Serverless-first cloud-native with container fluency and local cloud emulation
• Container tooling and CI/CD familiarity
• Clear, concise communication to technical and non-technical stakeholders

Responsibilities

• Own the technical integrity of a core backend platform, delivering secure, high-quality code on time
• Hands-on development and delivery leadership in a small specialist team
• Architect and implement event-driven patterns (event sourcing/CQRS) and domain models
• Enforce security by design with multi-tenant isolation and encryption
• Define and uphold test strategies, CI gates, and verification processes
• Leverage AI-assisted development responsibly, verifying outputs and tests

Skills

Event-driven architecture

CQRS

Domain-modeling

Multi-tenant security

Delivery leadership

AI-assisted development

Test strategy

Python

Relational databases

Serverless

Container tooling

CI/CD

Stakeholder communication

Job description

Job Description:

Senior hands-on engineer to own the technical integrity of a core backend platform - holding engineering quality, making build-vs-configuration calls under architectural direction, and anchoring a small specialist team. Accountable for delivery of their scope: built right, secured, on time, and clearly communicated. A hands-on expert engagement: building, not advising or overseeing.

This is core software development and transaction-processing work - building the operational backbone of a live system. It is not an analytics, data-warehousing, or business-intelligence role.

Must-have summary - the hard bar

• A candidate must clear all of these to be a fit:
• 8 12 years hands-on, currently building - recent, personally-built and delivered work they can speak to in depth.
• Event-driven architecture designed and built - event sourcing / CQRS as a design practice, not just message-bus usage.
• Domain-modeling judgment - can tell a genuinely new pattern from a variation of an existing one.
• Multi-tenant / multi-party security - has enforced tenant isolation server-side; understands event integrity and encryption at rest and in transit.
• Delivery leadership - accountability, execution discipline, clear communication (including to non-technical stakeholders), and sound escalation judgment.
• AI-assisted-development fluency and verification - directs and verifies AI-generated code and test suites, catching plausible-but-wrong output rather than rubber-stamping green.
• Test-strategy judgment - defines what a suite must prove and spots the gaps automated generation leaves.
• Strong Python; working relational-database / projection proficiency.
• Serverless-first cloud-native - object storage and serverless compute as primary building blocks; container fluency; local cloud emulation.
• Executes within locked decisions without relitigating; thrives in a direct, fast-moving small team.

Core skills - full detail

• 8 12 years hands-on, with recent work you personally built and delivered.
• Deep event-driven architecture - event sourcing, CQRS, or similar patterns designed and built, not just used.
• Strong domain-modeling judgment - telling a genuinely new pattern from a variation of an existing one.
• Strong specification skill - turning intent into instructions precise enough to build right the first time.
• Secure-by-design across the platform's layers:
  • Domain / data isolation - multi-tenant / multi-party isolation enforced server-side and re-authorized per request; paths and UI are never the isolation boundary.
  • Event / transport integrity - event authenticity and tamper-evidence (message signing), and encryption in transit across all edges and internal calls.
  • Encryption at rest - across the relational store, the event log, and object / lakehouse storage, with customer-managed keys.
• Security verification of AI-generated code - catches injection vectors, leaked secrets, and authorization bypasses in generated output before they land.
• Test strategy and verification judgment - defines what a suite must prove, and reviews generated tests for genuine coverage rather than green-but-hollow passing (edge cases, error paths, and boundaries automated generation tends to skip).
• Owns the test bar and CI gate - defines what must pass before merge, given humans gate generated changes.
• Hands-on with automated testing frameworks - unit / integration testing, service mocking / stubbing, and test-data generation, alongside local cloud emulation.
• Ownership and delivery discipline - accountable for getting work to done, holds a quality bar under time pressure, drives outcomes rather than waiting for direction.
• Clear communicator - surfaces risk early, reports status crisply, explains technical trade-offs to non-technical stakeholders.
• Sound escalation judgment - knows what to own and decide versus what to surface upward.
• Executes within locked architectural decisions without relitigating them; works well in a direct, fast-moving small team.
• Fluent with modern AI-assisted development tooling - directs and verifies AI-generated code with rigor.
• Strong Python proficiency.
• Working proficiency with relational databases and read-model / projection design - enough to hold the data layer if needed.
• Serverless-first cloud-native build - object storage and serverless compute as primary building blocks.
• Container fluency - containerized local development and container-image packaging of compute.
• Local cloud emulation for development and testing.
• Effective working from principles and open problems, not pre-written tickets.

Advantageous

• Configuration-driven platform experience - change absorbed as config, not rebuilds.
• Cloud-native architecture, streaming / event-processing platforms, serverless.
• Federated / keyless CI credentials, secrets management, least-privilege access design.
• Container orchestration - good to know, not required.
• Domain exposure in a data-intensive, operationally complex industry.

Assessment

A deep-dive on something you personally built, secured, and delivered - including how you enforced tenant isolation and protected data in transit and at rest - plus how you'd specify a non-trivial feature, verify the result, and judge whether its test suite actually proves correctness.