Inside Fora Soft’s Development Team: Stacks, Agent Engineering, and What It Takes to Ship

Why Fora Soft wrote this piece

Founders and CTOs evaluating development partners often ask the same thing: can this team actually ship? This piece answers that honestly. It’s a field report on how our engineering team is structured, which stacks we run, how code quality is enforced, where AI and agent methods sit in the workflow, and what you can expect in the first weeks of a project.

Fora Soft has shipped 625+ products over 20 years — video, AI, telemedicine, e-learning, surveillance, fintech. See real engagements: V.A.L.T. (770+ organizations, 2,000+ IP cameras), BrainCert (500M+ delivered minutes), Tradecaster. The engineering patterns we describe below are what keeps that shipping rate with a team sized around craftsmanship, not headcount theater.

How the engineering team is structured

Every project runs with a tech lead (senior, owns architecture and code review), a core build team (mid–senior, 2–6 depending on scope), and domain specialists on call (WebRTC, ML/AI, payments, video streaming). Above the tech lead sits a head of engineering who allocates resourcing, coaches on craft, and escalates hardware/cloud decisions that cross projects.

We deliberately stay senior-heavy. Most of our engineers have 5–12+ years in the relevant domain. We add juniors in structured apprenticeship under a lead, never as primary implementers on client work. That’s how we keep review cycles short and defect rates low.

Which stacks we run — and why we pick each

We’ll tell you the trade-offs we see before we let you pick. “Use what you know” usually wins on maintainability; but for real-time video, audio, or ML-heavy backends, the stack choice has material performance consequences.

Our engineering process, sprint by sprint

Sprint 0 — Tech architecture (1 week). The tech lead translates the analyst’s deliverables into architecture sketches, ADRs, API contracts, infrastructure plan, and a test strategy. Engineers read; questions land in sprint-1 backlog.

Sprints 1–N — Build (2-week sprints). Story pull, PR-driven development, CI enforced green, daily async standups. Every PR goes through at least one senior reviewer and automated checks (types, tests, lint, security).

Weekly tech-debt budget. 10–15% of each sprint is reserved for paydown — refactors, dep bumps, test-gap fills. Skipping this is the #1 reason projects slow down in month 3.

Pre-launch hardening (1–2 weeks). Load tests, security review, accessibility audit, chaos scenarios. Our QA team (see the QA team playbook) owns sign-off.

Post-launch SRE cadence. Observability stays live, weekly reliability reviews, monthly roadmap refresh. We don’t disappear after launch; most clients keep us on a maintenance engagement.

Figure 1. The engineering cadence across sprint 0, build, hardening, and post-launch.

Code quality: what it means operationally

1. Strict types at boundaries. TypeScript strict mode, pyright strict in Python, generics used where they prevent a class of bugs. Runtime validation at ingress (Zod, Pydantic) so API consumers can’t sneak bad data in.

2. Tests as first-class citizens. Unit tests for logic, integration tests for contracts, end-to-end for the critical user journeys. Coverage thresholds enforced in CI (typically 70%+ unit, 80%+ critical paths). Without the thresholds, coverage decays.

3. Code review discipline. Every PR reviewed; seniors review seniors. Review comments are direct but kind. Approved PRs merge via CI, not a button.

4. Architecture decision records (ADRs). Every non-trivial architectural choice is captured in a short markdown ADR (context, decision, consequences). Six months later, when someone asks “why did we pick X?”, the answer is on disk.

5. Observability day one. Structured logging, tracing, metrics from sprint 1, not added later. “It works on staging” is not a certification.

Agent engineering — how we ship faster without cutting corners

We use LLM-powered coding agents inside a strict review discipline. Agents draft, humans decide. The wins are concrete.

1. Spec-driven generation. Analyst specs feed agents that draft scaffolding, types, service boundaries, and tests. Humans iterate on the draft rather than starting from scratch. See the details in Spec-Driven Agentic Engineering.

2. Test synthesis. Agents propose edge-case tests from a spec plus an implementation. Engineers accept, edit, or reject. This is where agent-assisted coding delivers consistent quality — more tests, lower cost.

3. Code review assistant. Agents flag obvious regressions, missing null checks, and security anti-patterns before the human reviewer. Humans focus on design and intent.

4. Documentation generation. API docs, README stubs, architecture summaries from code + ADRs. Maintenance documentation stays current, which is rare in industry.

Effect on estimates: typical 6-month builds land in 10–14 weeks for first production. That’s why our quotes beat incumbents on both price and timeline — not because we skip steps, but because the agent compresses the routine.

Mini case: real-time audio on V.A.L.T. — the hard-to-fake wins

One of our longer-running engagements, V.A.L.T., needed a new Talkback feature — web-browser-to-IP-camera two-way audio across a fleet of cameras that included older, resource-constrained models. Latency had to stay under 300ms on the hot path; audio needed resampling, encoding normalization, and noise reduction; cameras without native WebRTC support required a shim.

What shipped: a rewritten frontend audio capture pipeline, a middle-tier audio processor handling resampling and noise reduction, backend adjustments for camera compatibility, and — as a side project — a Vite migration that cut the team’s frontend build from ~15 minutes to ~25 seconds. Result: usable Talkback on the client’s full camera fleet, and a measurable productivity lift on every subsequent feature because builds stopped being the bottleneck. The Vite story is the kind of “invisible” win that separates engineers who care from those who don’t.

Reliability engineering: the boring stuff that matters

1. SLOs before features. Availability, latency, and error-rate targets decided with the client; dashboards and alerts wired before the first user. See our deeper notes in How to make software reliable and crash-proof.

2. Blameless postmortems. Every incident gets a 5-why and a follow-up action list. Action items land in the backlog with an owner and a date.

3. Load testing. Before every launch and before every major feature. Synthetic users hit the same paths real users will.

4. Security review. Threat model at architecture time; OWASP Top-10 linted in CI; penetration test before production for any product with auth and sensitive data.

5. Disaster recovery drills. Quarterly on production-facing products. RTO/RPO documented and tested — not just written in a Confluence page.

Cloud, infra, and delivery stack

Hosting. AWS, GCP, Azure — we work in all three. For cost-sensitive video workloads we also use Hetzner AX-series and DigitalOcean. Cloudflare for edge and CDN.

Orchestration. Kubernetes for multi-service apps, Nomad for simpler stacks, ECS/Fargate for AWS-native teams. We use what the client’s operations team can run.

CI/CD. GitHub Actions, GitLab CI, Buildkite. Blue-green or canary deploys for any production system with real users.

Observability. Datadog, Grafana + Prometheus, OpenTelemetry. Structured logs to Loki or Cloudwatch. Alerting into PagerDuty or Opsgenie.

Data. Postgres as the default; Redis for caching; Kafka / NATS for event streams; Clickhouse or Snowflake for analytics workloads.

What engineering actually costs

Three realistic shapes for 2026, grounded in our recent projects:

We use agent engineering to compress timelines; our fixed-price deals land because we can scope cleanly after a 1–2 week spike. If the build is uncertain we say so; we don’t quote a number we can’t defend.

Decision framework — when to hire Fora Soft engineers

Q1. Is the product’s complexity in real-time, AI, or regulated systems? Yes: we’re a strong fit; our 20-year portfolio is concentrated there.

Q2. Do you need engineers who can make architecture decisions, not just execute? Yes: that’s how we staff. Our seniors are hired for judgment, not for ticket throughput.

Q3. Do you want a team that stays post-launch? Most of our clients stay with us on maintenance and iteration. We built for longevity.

Q4. Is speed-to-first-production critical? Agent engineering makes us fast without cutting corners. If you have a launch deadline tied to a business event, we’re the right call.

Q5. Is the engagement $40k+? Below that we may recommend a smaller partner — we’ll give you the referral rather than take a misfit contract.

Five engineering pitfalls on rescue projects

1. Everything in one big service. A 50k-line monolith with no module boundaries ruins the sprint-5 onwards. Refactor early.

2. No types. Dynamic-only JavaScript or untyped Python will eat your delivery speed by month 3. Types pay for themselves.

3. Skip observability. Teams who add logs in sprint 10 are flying blind when the first incident hits sprint 11.

4. Ignore tech debt budget. Without a standing 10–15% sprint allocation, debt compounds and velocity halves.

5. Missing reviews on junior PRs. Juniors shipping unreviewed code to production is the fastest way to turn a team into a firefight. Make reviews non-negotiable.

KPIs we hold the engineering team to

Quality KPIs. Defect escape rate to production (<3 per 10k LOC). Mean time to detect incident (<5min). Mean time to recover (<30min for SEV-2, <4h for SEV-1). Post-deploy rollback rate (<5%).

Velocity KPIs. Cycle time from PR open to merge (<2 days). Deployment frequency (multiple per day on mature projects). Lead time for change (hours, not weeks).

Cost KPIs. Estimate-to-actual variance (±15% ceiling on fixed-price). Cloud spend / DAU trend (should decline post-optimization). Engineering retention (>90% annually).

When you don’t need Fora Soft engineering

If your product is a simple CRUD app with no real-time, AI, or streaming component, and you have a capable in-house team, we’re probably over-qualified. If you need a single contractor to make quick changes on a legacy PHP site, a freelancer will serve you better than our delivery model.

Where we earn our seat: complex, reliable, multi-domain builds. That’s the work where our 20-year portfolio and engineering discipline compounds, and where agent engineering gives you real speed without corner-cutting.

Dedicated team model — when it’s the right pattern

For clients running ongoing product development, we offer a dedicated team — named engineers who work as an extension of your org for months or years. We’ve run 3–10 person dedicated teams for clients continuously for 5+ years. The pattern works when your roadmap is continuous and you want the same senior engineers owning product memory.

How we work with your team

Your tools. Jira, Slack, GitHub/GitLab, Linear, Notion, Confluence, PagerDuty — we plug into whatever your org runs on. Our engineers show up in your standups and retros.

Time zones. We span Europe and MENA time zones; major overlap with North American mornings and European working hours. Async-first where we can, synchronous where decisions need it.

Security and compliance. NDA + MSA before any code access. We hold SOC 2-aligned internal controls and can sign BAAs for HIPAA projects. Data-residency constraints respected at deployment.

Ownership handover. If we build for you, you own the code. Full handover docs at key milestones. We can transition to your in-house team or another vendor cleanly.

A note on culture

We value craft. That shows up as honest code reviews, refusal to ship obvious shortcuts, and a willingness to disagree with the client when we think we’re right. We also value kindness — in reviews, in retros, in client conversations. The two aren’t in tension; they’re what keeps senior engineers happy for years, which is why our retention is high and our quality is consistent.

What you feel on day one: engineers who care, push back when needed, and bring real judgment to the table. If that fits your team’s culture, the partnership will be long. If you want quiet order-takers, we’re not the right vendor.

FAQ

What to Read Next

Ready to hire engineers who earn their seat?

Engineering at Fora Soft is craft plus discipline plus the compounding speed of agent-assisted workflows. We ship reliable, observable, maintainable systems in the domains where it matters most — video, AI, telemedicine, surveillance, fintech. We staff seniors, we review every PR, we bake accessibility and compliance in from day one, and we stay post-launch. That’s 20 years of working the same way.

If that’s the engineering partner you want, a 30-min call is the shortest path from your brief to a plan and a range you can defend to your board.