<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Florian Chiorăscu on Medium]]></title>
        <description><![CDATA[Stories by Florian Chiorăscu on Medium]]></description>
        <link>https://medium.com/@fchiorascu?source=rss-ac2014a857bc------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*rMIpiC3fCqEbBoizdEBZ7Q@2x.jpeg</url>
            <title>Stories by Florian Chiorăscu on Medium</title>
            <link>https://medium.com/@fchiorascu?source=rss-ac2014a857bc------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 04:52:23 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@fchiorascu/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Leading from the Middle Across Teams]]></title>
            <link>https://medium.com/@fchiorascu/leading-from-the-middle-across-teams-faa74af4571d?source=rss-ac2014a857bc------2</link>
            <guid isPermaLink="false">https://medium.com/p/faa74af4571d</guid>
            <category><![CDATA[leadership]]></category>
            <dc:creator><![CDATA[Florian Chiorăscu]]></dc:creator>
            <pubDate>Sat, 03 Jan 2026 19:30:27 GMT</pubDate>
            <atom:updated>2026-01-03T20:26:06.097Z</atom:updated>
            <content:encoded><![CDATA[<h4>Practical notes on clarity, trust, and execution across software, GenAI/ML, and BI</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qCsygjKv4ns3zXWkUbKBmQ.png" /></figure><h3>Context</h3><p>My leadership journey started informally in 2021, when I proposed a small pilot and helped shape a team from scratch: two junior developers, a very experienced principal architect, and me. In 2022 I became an engineering manager officially. In 2025, the scope expanded: from one team to three teams with different missions (Software + GenAI/ML, Software Development, and Business Intelligence). In total: 11+ people (excluding me), three problem spaces, and a meaningful increase in expectations and delivery pressure.</p><p>This post isn’t about headcount. It’s about what changed operationally - and what helped me stay useful when the complexity went up.</p><h3>What changed when we went from one team to three</h3><p>The biggest shift wasn’t “more work.” It was <strong>more simultaneous realities</strong>:</p><ul><li><strong>Higher expectations, shorter time-to-market, higher complexity.</strong></li><li><strong>Context switching became the default</strong> (projects, stakeholders, tech stacks, delivery cadences).</li><li>I needed to move from “building the system” to <strong>keeping multiple systems healthy at the same time</strong> - teams, processes, quality, delivery, and communication.</li></ul><blockquote>What surprised me: the hardest part wasn’t coordination. It was <strong>energy/attention management</strong> - making sure I didn’t spend the day reacting, while teams waited for clarity.</blockquote><h3><strong>My default operating model: reduce noise, create clarity, keep the work consistent</strong></h3><p>When the scope expanded, I leaned into a simple baseline:</p><ul><li><strong>Reduce noise before adding process.</strong> If something feels chaotic, the instinct is to add meetings. I try to do the opposite: separate concerns, simplify decisions, and unblock the next step.</li><li><strong>Be easy to work with.</strong> Calm, responsive, direct. If a team needs a decision with partial information, I’d rather help land an “educated next step” and recalibrate than create analysis paralysis.</li><li><strong>Meet each team where they are.</strong> Different maturity levels, different “ways of working,” different people. My job isn’t to force uniformity; it’s to create enough structure for reliability - and enough flexibility for teams to move fast.</li></ul><blockquote>At scale, <strong>emotional intelligence shows up as self-awareness and self-regulation under pressure</strong>: staying calm enough to hear the signal, keep conversations constructive, and avoid reactive decisions.</blockquote><blockquote>And none of this works without real sponsorship: <strong>with senior leadership support, we had the room to start small, learn fast, and keep decisions close to the teams</strong> - especially when information was incomplete.</blockquote><p>A personal lesson here: when I scaled from one team to three, I had to <strong>let go of some expectations</strong> and invest more time in trust-building. Progress became less about “my standard” and more about “our shared standard.”</p><h3>Avoiding “poor-decision meetings”</h3><p>In larger scope, meetings can quietly become the biggest delivery risk. I try to keep a strict standard:</p><ul><li><strong>A meeting needs a purpose:</strong> decision, alignment, or unblocking.</li><li><strong>A meeting needs an owner:</strong> who is accountable for the outcome.</li><li><strong>A meeting needs an output:</strong> action items, owners, and a timestamp.</li></ul><p>If those aren’t possible, we don’t need a meeting - we need a clearer problem statement, or a smaller working group.</p><p>This is also where I intentionally stay practical: I focus on <strong>24-hour clarity</strong> (“what changes tomorrow because of this?”), not just long-term alignment.</p><h3>People leadership: trust, reality, and growth without theater</h3><p>Across three teams, the human system matters more than the process system.</p><p>What worked best for me:</p><ul><li><strong>Start by observing.</strong> In the first weeks, I listened: delivery patterns, friction points, decision flow, reliability signals, and team dynamics. Then 1:1s, lightweight surveys, and follow-ups.</li><li><strong>Directness with respect.</strong> Especially when there’s mismatch between self-perception and outcomes. No shaming, no “gotcha,” no sarcasm - just clarity and support.</li><li><strong>Create space before asking for change.</strong> Removing blockers first builds credibility. Only then do deeper conversations land.</li></ul><blockquote>The hard part: some people struggle with transparency and accountability - not because they’re “bad,” but because it’s unfamiliar. Habits change slowly. My approach is iterative: clarity → support → feedback → recalibration.</blockquote><h3>GenAI adoption (kept grounded)</h3><p>We also explored GenAI in a practical way, without turning it into a slogan.</p><p>At a high level, what mattered:</p><ul><li><strong>Structured prompts and structured outputs.</strong> We treated prompts as versioned assets and pushed toward predictable outputs (e.g., JSON + schema validation) where it helped reliability.</li><li><strong>Guardrails and costs.</strong> We paid attention to latency, token usage, and operational constraints - not just model behavior.</li><li><strong>Human-in-the-loop where needed.</strong> Especially for anything evaluative or high-impact.</li></ul><p>The best outcome wasn’t “AI everywhere.” It was <strong>selective leverage</strong>: using GenAI where it removed repetitive work or improved feedback loops, while keeping engineering discipline intact.</p><h3>Closing reflection</h3><blockquote>Managing multiple teams isn’t a badge. It’s mostly work on clarity - ownership, decision hygiene, and protecting focus. I try to keep it simple: reduce noise, be clear, and help teams stay autonomous without drifting. <a href="https://brenebrown.com/articles/2018/10/15/clear-is-kind-unclear-is-unkind">Brené Brown</a></blockquote><h3><strong>References</strong></h3><ul><li><em>Simon Sinek - Start With Why<br> </em><a href="https://simonsinek.com/books/start-with-why/"><em>https://simonsinek.com/books/start-with-why/</em></a></li><li><em>Simon Sinek - Leaders Eat Last<br> </em><a href="https://simonsinek.com/books/leaders-eat-last/"><em>https://simonsinek.com/books/leaders-eat-last/</em></a></li><li><em>Simon Sinek - The Golden Circle<br> </em><a href="https://simonsinek.com/golden-circle/"><em>https://simonsinek.com/golden-circle/</em></a></li><li><em>Brené Brown - Dare to Lead<br> </em><a href="https://brenebrown.com/book/dare-to-lead/"><em>https://brenebrown.com/book/dare-to-lead/</em></a></li><li><em>HBR: What Is Psychological Safety?<br> </em><a href="https://hbr.org/2023/02/what-is-psychological-safety"><em>https://hbr.org/2023/02/what-is-psychological-safety</em></a></li><li><em>McKinsey: Psychological safety &amp; leadership in a time of flux </em><a href="https://www.mckinsey.com/featured-insights/leadership/psychological-safety-emotional-intelligence-and-leadership-in-a-time-of-flux"><em>https://www.mckinsey.com/featured-insights/leadership/psychological-safety-emotional-intelligence-and-leadership-in-a-time-of-flux</em></a></li><li><em>Daniel Goleman (HBR): What Makes a Leader?<br> </em><a href="https://hbr.org/2004/01/what-makes-a-leader"><em>https://hbr.org/2004/01/what-makes-a-leader</em></a></li><li><em>Camille Fournier<br> </em><a href="https://www.camilletalk.com/"><em>https://www.camilletalk.com/</em></a></li><li><em>Camille Fournier - The Manager’s Path<br> </em><a href="https://books.google.com/books?id=zqNaDgAAQBAJ&amp;printsec=frontcover"><em>https://books.google.com/books?id=zqNaDgAAQBAJ&amp;printsec=frontcover</em></a></li><li><em>Kim Scott -Radical Candor<br> </em><a href="https://www.radicalcandor.com/the-book"><em>https://www.radicalcandor.com/the-book</em></a></li><li><em>Vanessa Van Edwards - Science of People <br> </em><a href="https://www.scienceofpeople.com/"><em>https://www.scienceofpeople.com/</em></a></li><li><em>Jefferson Fisher <br> </em><a href="https://www.jeffersonfisher.com/"><em>https://www.jeffersonfisher.com/</em></a></li><li><em>HBR: Metacognition<br></em><a href="https://hbr.org/2012/10/collaborating-across-cultures"><em> https://hbr.org/2012/10/collaborating-across-cultures</em></a></li><li><em>Servant Leadership: </em><a href="https://greenleaf.org/what-is-servant-leadership/"><em>https://greenleaf.org/what-is-servant-leadership/</em></a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=faa74af4571d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How We Started with Nothing and Built a Full-Cycle Dev Team]]></title>
            <link>https://medium.com/@fchiorascu/how-we-started-with-nothing-and-built-a-full-cycle-dev-team-aba9a7988f5b?source=rss-ac2014a857bc------2</link>
            <guid isPermaLink="false">https://medium.com/p/aba9a7988f5b</guid>
            <dc:creator><![CDATA[Florian Chiorăscu]]></dc:creator>
            <pubDate>Mon, 31 Mar 2025 00:52:56 GMT</pubDate>
            <atom:updated>2026-01-03T20:42:23.515Z</atom:updated>
            <content:encoded><![CDATA[<h3>How We Built a Full-Cycle Development Team from Scratch</h3><h4>Practical lessons from a small team and a greenfield pilot</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wPmHF7bugoIVd-4j7NaVgA.png" /></figure><h3>Context</h3><p>We ran an internal greenfield pilot with a clear timebox (about a year) and one goal: shorten the feedback loop and deliver something reliable enough for day-to-day use.</p><h4><strong>Stages used in this story</strong></h4><ul><li><strong>PoC → Prototype → MVP → Pilot → RC → Go-live (GA)</strong></li></ul><p>At peak, we were four people: three junior engineers (including me, hands-on) and a principal-level architect with deep experience building and operating systems at scale. Leadership sponsorship gave us the space to run this as a focused pilot team and keep execution lightweight.</p><p>Early on, we defaulted to backend-first because it felt efficient. Once the workflow and UI/UX became concrete, we had to reshape parts of the backend to match real usage.</p><blockquote><strong>The code wasn’t sloppy. The assumptions were early.</strong></blockquote><p>From that point, we changed our default to workflow-first: start with the user flow, make behavior explicit, then align the backend to serve it. That shift made delivery more predictable and reduced rework.</p><h3>Full-cycle delivery in practice</h3><p>We borrowed the idea behind Netflix’s “full-cycle developers”: optimize time-to-value by keeping ownership close to the work — build it, ship it, operate it, learn from it. <a href="https://netflixtechblog.com/full-cycle-developers-at-netflix-a08c31f83249">Netflix Tech Blog</a></p><p>In our pilot initiative, we applied that mindset end-to-end - from early feasibility through go-live (GA) - but kept the mechanics lightweight.</p><p>For us, full-cycle meant:</p><ul><li><strong>Own the whole slice:</strong> UI → API → services → persistence, with fewer handoffs.</li><li><strong>“Done” included basic operability:</strong> enough logging/metrics to troubleshoot without guesswork.</li><li><strong>Ship small, ship often:</strong> frequent deployments kept changes reversible and feedback real.</li><li><strong>Close the loop:</strong> production signals shaped what we built next — quietly and consistently.</li></ul><p>Full-cycle didn’t mean everyone became an expert in everything. It meant we treated delivery as one system and kept accountability end-to-end.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dPaFS7lJvSdABBw-ZCv6Gw.png" /></figure><h3>Test-Driven Development (TDD)</h3><p>With a small team, frequent deployments, and a product still taking shape, we needed a repeatable safety net. <a href="https://martinfowler.com/bliki/TestDrivenDevelopment.html">Test-Driven Development </a>(TDD) gave us fast feedback and made refactoring feel routine instead of risky.</p><blockquote><em>We kept it simple: 🔴 </em><strong><em>Red</em></strong><em> → 🟢 </em><strong><em>Green</em></strong><em> → 🔁 </em><strong><em>Refactor</em></strong><em> - guided by the classic “three rules” discipline (fail first, write the minimum, then pass).</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fDtZjN1QLuRkz82flYIX9A.png" /></figure><p>We experimented with two common styles:</p><ul><li><strong>Chicago (Classicist):</strong> start from the core and verify <strong>outcomes/state</strong>, using real collaborators by default (mocks mainly at slow/IO boundaries). <a href="https://martinfowler.com/articles/mocksArentStubs.html">martinfowler.com</a></li><li><strong>London (Mockist):</strong> start from an outer behavior and verify <strong>interactions</strong>, using mocks to shape seams and drive design from the edges inward. <a href="https://martinfowler.com/articles/mocksArentStubs.html">martinfowler.com</a></li></ul><blockquote><strong>Arrange</strong>-<strong>Act</strong>-<strong>Assert (AAA) </strong>gave us a consistent test shape:</blockquote><blockquote><strong>setup</strong>, <strong>action</strong>, <strong>outcome</strong>.</blockquote><pre>def add(a: int, b: int) -&gt; int:<br>    return a + b<br><br>def test_add_returns_sum_of_two_numbers():<br>    # Arrange<br>    a, b = 1, 2<br>    # Act<br>    result = add(a, b)<br>    # Assert<br>    assert result == 3</pre><h3>Behavior-Driven Development (BDD)</h3><p>Test-Driven Development (TDD) helped us design and refactor safely. Behavior-Driven Development (BDD) helped us stay aligned on <strong>what the system should do</strong> - in plain language - before we debated implementation details. <a href="https://agilealliance.org/glossary/bdd">Agile Alliance</a></p><blockquote><strong>Given-When-Then (GWT)</strong> gave us a shared structure for behavior:</blockquote><blockquote><strong>context → action → expected outcome</strong>. <a href="https://martinfowler.com/bliki/GivenWhenThen.html">martinfowler.com</a></blockquote><pre>Scenario: Adding one item updates the total<br>  Given the cart is empty<br>  When I add an item priced 10<br>  Then the total is 10</pre><pre>def test_cart_total_updates_after_adding_item():<br>    # Given<br>    total = 0<br>    # When<br>    total += 10<br>    # Then<br>    assert total == 10</pre><p>We didn’t treat BDD as a tool choice. We treated it as a way to keep workflows and acceptance criteria concrete - especially when UI/UX and behavior were evolving.</p><h3>Architecture baseline - simple layers, clear seams</h3><p>We needed an architecture that was easy to reason about, easy to test, and resilient to change. We kept it deliberately simple: a layered structure with explicit boundaries, aligned with the “dependencies point inward” mindset from Clean Architecture. <a href="https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html">Clean Coder Blog</a></p><p>In practice, that meant:</p><ul><li><strong>REST controllers:</strong> handle HTTP concerns (request/response, validation, mapping).</li><li><strong>Services (use-cases):</strong> orchestrate the workflow and keep business decisions in one place. <a href="https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html">Clean Coder Blog</a></li><li><strong>Repositories:</strong> isolate persistence and give us a clean seam for testing and iteration.<a href="https://fitech101.aalto.fi/en/courses/web-software-development-v1/part-3/7-crud-repository-layered-architecture"> fitech101.aalto.fi</a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*9yom8jlxiVvvSZ33r1sa9w.png" /></figure><h3>How we worked</h3><p>We kept process lightweight and focused on flow. The goal was simple: spend most of the day building, not coordinating.</p><p><strong>Cadence</strong></p><ul><li><strong>Monthly outcomes:</strong> a clear “what should be true in ~4 weeks” target (features + quality + operational readiness).</li><li><strong>Weekly commitment:</strong> work small enough to finish in days, not weeks.</li><li><strong>WIP = 1 per person:</strong> one active story at a time, to reduce thrash and increase throughput.</li></ul><p><strong>Daily rhythm</strong></p><ul><li><strong>Daily production deployments:</strong> small changes, shipped often.</li><li><strong>One alignment window per day:</strong> a fixed slot for reviews / pairing / unblockers. Everything else was protected focus time.</li></ul><p>This structure helped us keep changes small, make issues visible early, and avoid the slow drift that happens when work-in-progress piles up.</p><h3>What we measured</h3><p>We kept metrics few and practical. The goal wasn’t reporting - it was early signal when flow or quality started to drift.</p><ul><li><strong>Lead time:</strong> how long a change took from “requested” to “done/shipped.” <a href="https://www.atlassian.com/agile/project-management/kanban-metrics">Atlassian</a></li><li><strong>Deployment frequency:</strong> how often we shipped to production. <a href="https://dora.dev/guides/dora-metrics/">Dora</a></li><li><strong>Change failure / escaped defects:</strong> how often a deployment caused an incident, rollback, or hotfix (and what slipped past before release). <a href="https://dora.dev/guides/dora-metrics/">Dora</a></li><li><strong>Time to restore service:</strong> how quickly we recovered when something broke. <a href="https://dora.dev/guides/dora-metrics/">Dora</a></li><li><strong>Test suite health:</strong> flakiness and feedback time (if tests are slow or unreliable, they stop protecting you).</li><li><strong>Technical debt trend:</strong> whether refactoring stayed part of the work, or got deferred until it became expensive.</li></ul><h3>Generative AI with small language models (SLMs)</h3><blockquote><em>Structured prompts, schema-checked outputs, and a realistic cost/quality trade-off</em></blockquote><p>We explored GenAI using <strong>small language models (SLMs)</strong> (e.g., Llama) for internal use cases where control and cost mattered. <a href="https://arxiv.org/html/2408.02442v1">arXiv</a><br> What made it workable was treating it like an engineering integration.</p><ul><li><strong>Structured inputs/outputs:</strong> system + user prompts in plain <strong>text/Markdown/YAML</strong>, and outputs constrained to <strong>JSON</strong> and validated against a schema. (Schema-driven outputs are a common production pattern for reducing parsing/contract drift.) <a href="https://platform.openai.com/docs/guides/structured-outputs">OpenAI Platform+1</a></li><li><strong>Shared semantics:</strong> once the output has fixed fields/enums, you naturally converge on a <strong>shared taxonomy</strong> (consistent labels and categories). Over time, that becomes a lightweight semantic model - enough to keep meaning consistent, without claiming a “formal <strong>ontology</strong>.”</li></ul><blockquote><strong>Trade-off (measured, not assumed):</strong> prompt/output format affects both <strong>quality and cost</strong>, and it’s <strong>model- and task-dependent</strong>. A recent study shows format restrictions can change performance (sometimes negatively for reasoning), and it also reports <strong>meaningful cost differences across text/JSON/XML/YAML depending on the model</strong>. <a href="https://arxiv.org/html/2408.02442v1">arXiv+1</a></blockquote><h3>Culture</h3><blockquote>In a small team, culture isn’t a slide deck - it’s what happens when work is unclear, deadlines are real, and something breaks</blockquote><p>Two norms mattered most:</p><ul><li><strong>Psychological safety:</strong> people could raise issues early, admit uncertainty, and ask for help without fear of blame.</li><li><strong>Consistency over heroics:</strong> we relied on small batches, clear “done,” and steady review habits - not late-night rescues.</li></ul><p>That combination made it easier to choose the uncomfortable truth over the comfortable shortcut - and to fix problems while they were still small.</p><h3>Final thoughts</h3><p>Looking back, the biggest shift wasn’t a tool or a framework. It was moving from “building components” to “delivering workflows” with end-to-end accountability.</p><p>If I had to summarize what helped most in our context:</p><ul><li><strong>Keep the loop tight:</strong> ship small, learn fast.</li><li><strong>Anchor work in real workflows:</strong> it reduces rework and improves alignment.</li><li><strong>Use tests as a design tool:</strong> they make change safer and refactoring normal.</li><li><strong>Keep architecture simple and predictable:</strong> fewer seams, fewer surprises.</li><li><strong>Protect team norms:</strong> clarity, candor, and consistency beat heroics.</li></ul><h3><strong>References</strong></h3><ul><li><em>Netflix Tech Blog - Full Cycle Developers at Netflix<br> </em><a href="https://netflixtechblog.com/full-cycle-developers-at-netflix-a08c31f83249"><em>https://netflixtechblog.com/full-cycle-developers-at-netflix-a08c31f83249</em></a></li><li><em>Robert C. Martin (Uncle Bob) - The Clean Architecture<br> </em><a href="https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html"><em>https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html</em></a></li><li><em>Robert C. Martin (Uncle Bob) - The Cycles of TDD </em><a href="https://blog.cleancoder.com/uncle-bob/2014/12/17/TheCyclesOfTDD.html"><em>https://blog.cleancoder.com/uncle-bob/2014/12/17/TheCyclesOfTDD.html</em></a></li><li><em>Martin Fowler (TDD) </em><a href="https://martinfowler.com/bliki/TestDrivenDevelopment.html"><em>https://martinfowler.com/bliki/TestDrivenDevelopment.html</em></a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aba9a7988f5b" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>