FreeIPA vs 389 Directory Server: when a plain LDAP directory is enough
FreeIPA uses 389 Directory Server as its directory, so this choice is about scope, not engine. Both store users, groups, hosts and policies in the same LDAPv3 server. What you decide is whether you also want the Kerberos KDC, the Dogtag certificate authority, DNS and host policy that FreeIPA wraps around it, and whether you want to build and operate those pieces yourself.
The bare 389 Directory Server fits when applications need an LDAP directory and little else. It suits a team that already runs its own certificate process, its own DNS and its own SSO layer, and that is comfortable writing the schema, provisioning scripts and ACIs that the directory needs. 389 Directory Server offers multi-supplier replication, online configuration through LDAP operations, and the dscreate, dsconf and dsidm tools for administration, so a skilled LDAP team can run it well on its own. It also has a conversion path: the openldap_to_ds command can migrate an OpenLDAP estate on a best-effort basis, though you should test what it carries over, including overlays.
FreeIPA fits when Linux hosts are the main consumers of identity. Kerberos single sign-on, central sudo and HBAC rules, an integrated CA issuing host and service certificates, and DNS that clients resolve against are all native to the product. Building those on bare LDAP means writing and supporting each one separately, with its own renewal, replication and security patching. FreeIPA's own deployment guidance also expects dedicated servers, at least two to three replicas per datacenter and careful handling of which replica runs PKI or DNS, so the operational load is real. Confirm the current release and patch line before you plan, since FreeIPA 4.13.4 fixed two CVEs in July 2026 (see the FreeIPA 4.13.4 release notes). The decision turns on three questions. First, which integrations must be native rather than assembled: if Kerberos, host policy or certificate issuance are requirements, the bare directory leaves them to you. Second, what skills you have in-house across LDAP schema, Kerberos and PKI. Third, how much you are willing to build and maintain yourself over the next several years. A DeployOpen scoping conversation usually starts with those three answers, and the written scope then sets the work and deliverables.
Which scenario points to FreeIPA and which to 389 Directory Server
This table maps common situations to the platform that fits better and the condition that decides it. Read each row as a question about your environment: if the condition holds, the named platform is the simpler path; if it does not, check the other column before committing.
| Scenario | Better fit | Condition that decides it |
|---|---|---|
| LDAP back end for internal applications | 389 Directory Server | Applications only need bind, search and group lookups over LDAP and no Kerberos, host policy or certificates. The team designs the schema, ACIs and any self-service tooling itself. |
| Linux fleet needing Kerberos single sign-on | FreeIPA | Users log in to many Linux hosts and services with one ticket-based credential. FreeIPA bundles the MIT Kerberos KDC, so the team does not assemble realms, principals and keytabs by hand. |
| Service certificates for internal hosts and services | FreeIPA | You need certificates issued and renewed from an internal CA with an audit trail. FreeIPA includes the Dogtag CA, while the bare directory has no certificate authority and the team must add one. |
| Central sudo and HBAC rules across hosts | FreeIPA | Access and privilege policy must be defined once and pushed to host groups. FreeIPA stores sudo and host-based access rules natively, whereas 389 Directory Server stores only the raw entries and you write the enforcement. |
| Coexistence with an Active Directory forest | FreeIPA | Linux users must reach resources and AD users must reach Linux services. FreeIPA can set up a cross-forest trust, and the IPA DNS domain must not overlap any AD forest domain. A bare directory has no built-in trust path. |
| Migration from OpenLDAP | 389 Directory Server | The goal is a standards-based LDAPv3 replacement with the same directory model. The openldap_to_ds tool converts on a best-effort basis, so verify schema, overlays and indexes in a test run. Choose FreeIPA only if you also want Kerberos and CA services in the same move. |
| Small team with no Kerberos need | 389 Directory Server | Few hosts, no SSO requirement across Linux services, and no certificate lifecycle to manage. A directory alone is smaller to run, but confirm that application logins do not depend on Kerberos or AD trusts later. |
| Multi-master replication for a directory-only service | 389 Directory Server | Your main requirement is replicated directory data across sites. 389 Directory Server offers asynchronous multi-supplier replication on its own. FreeIPA adds replica planning for DNS and PKI on top, which you only need if those services run. |
| Full identity stack with backup and host policy in one product | FreeIPA | You want directory, Kerberos, CA, DNS and host policy under one backup and upgrade process. Plan replica counts and confirm backup restore procedures with the FreeIPA backup documentation before go-live. |
How the FreeIPA stack and the bare directory are built
FreeIPA is not a separate directory product. It wraps 389 Directory Server with Kerberos, a certificate authority, client tooling and optional DNS and time services, and its deployment guidance shapes how many servers you run. The cards below separate what the bare directory gives you from what the full stack adds, so you can weigh the operating load against the services you actually need.
The 389 Directory Server core
The directory engine uses asynchronous multi-supplier replication, so writes can land on any supplier and propagate to the others. Schema, configuration and access controls can be changed online through LDAP operations without a restart. Day-to-day work is split across dscreate for instance creation, dsctl for local start, stop and backup, dsconf for configuration, dsidm for identity content and a Cockpit console. Check whether your team can run that toolset without FreeIPA's wrapper.
Kerberos and certificates on top
FreeIPA adds an MIT Kerberos KDC for single sign-on and a Dogtag certificate authority that issues certificates to hosts and services. The bare directory has neither, so Kerberos principals, keytabs and certificate lifecycle become work you build and maintain yourself. Confirm which of these you need on day one, because the CA and KDC are the parts that tie the topology to the replicas that hold them.
Client and service layer
SSSD runs on enrolled Linux clients and handles identity lookups, caching and Kerberos authentication against the server. Optional ISC BIND DNS and NTP can run alongside the servers, so host names and time sources are managed in the same deployment. If you already run DNS and time elsewhere, decide whether to keep them separate, since FreeIPA's guidance asks you to plan DNS redundancy in each client's resolver configuration.
Replica topology guidance
FreeIPA's deployment recommendations advise at least two to three replicas in each datacenter and no more than four replication agreements per replica. They also call for dedicated servers without other applications, and at least one replica per datacenter running PKI or DNS if you use those services. Use this as the sizing baseline for a quote: each extra datacenter multiplies replica count, and the bare directory has no equivalent of these services to place.
Packaging across distributions
FreeIPA is packaged for Fedora, Debian and CentOS, and as Identity Management in Red Hat Enterprise Linux. The 389 Directory Server core is packaged separately as 389-ds on openSUSE Leap 15 and Tumbleweed, and as 389-ds-base on Fedora and CentOS 8. Check your distribution's package name and support window before you pick a build, because the full stack and the bare directory may not come from the same repositories on your estate.
Capabilities that separate a FreeIPA install from a bare 389 Directory Server
This table lists the capabilities that a FreeIPA install adds on top of 389 Directory Server, and what the bare directory leaves to your team. Read each row as a question: if your estate needs the capability, the right column tells you whether you get it in the box or must design, build and operate it yourself. Note that the FreeIPA web UI first arrived as a beta in 4.13.0, and confirm current UI maturity against the release you plan to deploy.
| Capability | FreeIPA (bundled) | Bare 389 Directory Server |
|---|---|---|
| License | GPL-3.0-or-later, community project with no paid edition | GPLv3 code with CC BY-SA 4.0 documentation, no paid edition named in the facts |
| LDAP protocol support | LDAPv3 directory for users, groups, hosts and policies, built on 389 Directory Server | LDAPv3 compliant with TLS and SASL support |
| Kerberos single sign-on | Included through an MIT Kerberos KDC | Not included, must be deployed and integrated separately |
| Certificate authority | Integrated Dogtag CA issues host and user certificates | Not included, requires an external or separately built CA |
| DNS and NTP | Optional ISC BIND DNS and NTP components, DNS over TLS added in 4.13.0 | Not included, DNS and time services are managed outside the directory |
| Host, sudo and HBAC policy | Central host-based access control and sudo rules managed in the platform | Not included, sudo and HBAC rules must be modeled and maintained by hand in LDAP |
| OTP two-factor (HOTP and TOTP) | Software and hardware tokens, with OTP checks proxied to an existing RADIUS server | Not included, requires a separate OTP service or application |
| Multi-supplier replication | Built on 389 Directory Server replication, with FreeIPA topology guidance for replica counts per datacenter | Asynchronous multi-supplier replication, with topology design left to your team |
| Online configuration | Managed through FreeIPA tools and the web UI, which first arrived as a beta in 4.13.0 | Schema, configuration and ACIs updated online through LDAP operations with zero downtime |
| Migration tooling | ipa migrate-ds for users and groups, with sudo and HBAC rules migrated manually by LDIF | openldap_to_ds converts an OpenLDAP server on a best-effort basis |
| Active Directory cross-forest trust | Trust through Samba components, requiring a non-overlapping IPA DNS domain | Not included, AD trust must be designed on top of the directory |
| Administration tooling | FreeIPA command line and web UI for identity, certificate and policy tasks | dscreate, dsctl, dsconf and dsidm for instances, with a Cockpit web console |
How replication and backups differ between the bare directory and FreeIPA
With a bare 389 Directory Server, the team designs the replication topology itself. 389 Directory Server provides asynchronous multi-supplier replication for fault tolerance and high write performance, and port389.org says database size is restricted only by disk space. That flexibility is useful, but every decision is yours: how many suppliers exist, which ones replicate to which, how each site is covered, and how failover is handled by your applications. You also own the consequences of a bad topology, such as writes that take time to converge across suppliers or a site that loses its only path to the directory. Confirm with the 389 Directory Server project which topology patterns it recommends for your number of sites before you commit to one.
FreeIPA takes most of that design work off your hands by publishing a layout. Its deployment recommendations advise at least two to three replicas in each datacenter, no more than four replication agreements per replica, and at least one replica per datacenter running PKI or DNS if you use those services. Dedicated servers without other applications are also recommended. The benefit is a tested starting point. The cost is that you must still fit your sites into that shape and keep it intact as you add or retire replicas. Ask your vendor or DeployOpen to show the replica map for your sites and the reasoning behind it, because the recommendations are guidance, not a substitute for an approved design.
Backups carry a different risk. FreeIPA provides ipa-backup and ipa-restore, with full or online data-only backups. Its backup documentation warns that the first server handles certificate renewal and CRL publication by default, so an outage of that server affects certificate lifecycle as well as logins. It also warns that restoring an outdated backup into an active replica topology can break replication. In a bare directory you control the backup tooling and the restore sequence, which means you carry that same risk without a published runbook. Either way, rehearse restores in an isolated environment, record which server holds the renewal role, and never restore a backup over a live topology without a documented procedure for re-establishing replication.
The bare directory is acceptable when your team already runs LDAP at scale, needs custom topology or schema control, and has no requirement for Kerberos, an internal CA or host policy from the same product. FreeIPA is acceptable when you want one supported topology and one backup and renewal model across identity, certificates and DNS, and you can staff the operating model it implies. If neither condition fits, plan the operating roles before choosing.
Licensing and editions: both are community projects
FreeIPA is licensed under GPL-3.0-or-later, and the project itself has no paid edition. The software bundles 389 Directory Server, MIT Kerberos, the Dogtag certificate system and optional DNS and NTP services into one identity platform, so the license covers the whole stack you deploy. Under GPL terms you can run, modify and redistribute it, subject to the license conditions.
- No project-level paid tier: Nothing in the project's own licensing introduces a feature-gated or subscription edition.
- Distribution packaging: FreeIPA is packaged in Fedora, Debian and CentOS, and Red Hat Enterprise Linux ships it as Identity Management, a supported product with its own subscription terms.
- Support scope differs by source: Community packages come with community support, while the Red Hat build is supported only within its RHEL subscription. The sibling comparison on FreeIPA and Red Hat Identity Management covers that difference in detail.
- Services are separate spend: Installation, hardening, upgrades and support from a vendor or integrator are their own agreements, not license purchases.
Before budgeting, confirm with your distributor or vendor which support options apply to your distribution and version. Ask whether any fees, subscriptions or support terms are tied to the platform you choose.
389 Directory Server is the LDAP directory engine inside FreeIPA, and it is also a standalone product you can run without the rest of the stack. Its code is licensed under GPLv3, and its documentation is licensed under CC BY-SA 4.0, which covers how you may reuse and adapt the manuals in your own internal runbooks. The current release lines are 3.3.1, 3.2.3 and 3.1.5, all released on September 7, 2026.
- Code license: GPLv3 applies to the server software you install, patch or redistribute.
- Documentation license: CC BY-SA 4.0 applies to the project documentation, which matters if you republish or adapt it.
- Release lines: Track 3.3.1, 3.2.3 and 3.1.5 as the current lines, and confirm which line your operating system package follows.
- Packaging: The server ships as the 389-ds package on openSUSE and as 389-ds-base on Fedora and CentOS, so the package name and update channel depend on your distribution.
No paid edition is supplied for 389 Directory Server. Ask your Linux distributor or any support provider whether commercial support is available for your version, and what it covers before you budget for it.
Both projects are community-licensed, so the commercial question is about who supports the software in production, not about which edition to buy. Compare the support routes across both products in the same procurement exercise so the costs and responsibilities line up.
- Support source: Identify whether support comes from the distribution, a platform vendor or an independent integrator.
- Coverage window: Ask how long each release line receives fixes and which lines your team will run.
- Responsibility split: Agree in writing who handles patches, backups, certificate renewal and incident response.
- Documentation reuse: Check that your internal documentation practices fit CC BY-SA 4.0 terms if you adapt upstream material.
- Procurement evidence: Request the license text, support terms and current release information from the source you buy through.
Confirm every support option, fee and coverage term with the vendor or distributor in writing before you rely on it in a budget.
What drives running cost for each option
Neither project charges a license fee. FreeIPA is GPL-3.0-or-later with no paid edition of its own, and 389 Directory Server is GPLv3, so the cost of either option is the people who design, install, operate and support it, the servers it runs on, and any support contract you buy from a vendor or partner. The biggest difference is what each option makes you build. A FreeIPA install delivers Kerberos, the Dogtag certificate authority, DNS and host policy in one package, while the bare directory leaves those pieces for your team to design and maintain.
One-time costs cluster around design and proving the system works. For FreeIPA, that means choosing the replica layout, the DNS domain (which must not overlap with any Active Directory domain if you plan a trust), and the certificate authority model, then enrolling clients and testing what happens when a replica fails and when a backup is restored. For the bare directory, add the work of building Kerberos, certificate issuance, host policy and their integrations yourself, plus migration with openldap_to_ds if you are moving from OpenLDAP. Ask any partner to quote replica failure and restore testing as a named deliverable, not an assumed step.
Recurring costs are patching, upgrades, operating replicas and DNS servers, and on-call effort. FreeIPA's deployment recommendations advise at least two to three replicas in each datacenter, dedicated servers without other applications, at least one replica per datacenter running PKI or DNS if you use them, and at least two DNS servers in each client's resolv.conf. Each of those choices adds machines, monitoring and patch cycles, so the footprint is larger than a single directory service. The bare directory can run on fewer servers, but every custom Kerberos, certificate or policy component you build carries its own upgrade and testing burden, and FreeIPA's security fixes such as those in 4.13.4 must be applied by someone on your team either way. When requesting a quote, ask for the scope and written deliverables, who operates each component after handover (directory, Kerberos, CA, DNS, backups), which upgrades and security patches are included and for how long, and whether restore testing is part of the price. Confirm with the vendor or partner whether support for your platform version is covered by the subscription. The quote should state what the team must still do internally.
Moving between the bare directory and FreeIPA: what transfers and in what order
This sequence shows what moves from a standalone 389 Directory Server into FreeIPA, what FreeIPA regenerates on its own, and what has to be rebuilt by hand before clients and applications can cut over. Follow it in order, because the Kerberos realm, certificates and DNS depend on decisions made earlier in the sequence.
Inventory schema, users, groups and access rules
The directory owner lists every object class, attribute, user, group, ACI and sudo or host rule in the current directory, then marks which ones FreeIPA will own and which will be retired. Schema extensions that applications depend on need an owner and a test plan before anything moves. Done means a written inventory signed off by the directory owner and the application owners, with each sudo and HBAC-style rule recorded as a manual migration item, since FreeIPA's migration guidance does not carry those across automatically.
Build the target FreeIPA topology first
The platform team installs the new FreeIPA servers with the replica count and placement that the FreeIPA deployment recommendations describe, including at least one replica per datacenter running PKI or DNS if those services are used. The new realm is created with its own Kerberos realm and DNS domain, and the install is validated before any data moves. Done means replication between the new replicas is healthy and the team has confirmed the realm name and DNS domain with the owners of the existing environment.
Migrate users and groups with ipa migrate-ds
The team runs
ipa migrate-dsagainst the source directory to import users and groups into FreeIPA. The tool excludes Kerberos attributes, which FreeIPA regenerates, so existing passwords and Kerberos keys do not carry over and users will need a reset or a controlled first-login process. Done means a count of imported users and groups matches the inventory, with exceptions logged, and a sample of accounts has been checked for group membership and attribute values.Rebuild Kerberos, certificates and DNS in the new install
The Kerberos realm, the Dogtag certificate authority and the DNS zones are created in the new FreeIPA deployment rather than copied from the bare directory, since the bare directory did not provide those layers. The team sets the CA design, records who holds renewal and CRL duties, and confirms that clients will resolve the new DNS names. Done means a test host can obtain a Kerberos ticket, a test service certificate is issued and renewed, and DNS lookups return the expected records from every replica.
Migrate sudo and HBAC rules by hand
Sudo rules and host-based access control rules are recreated in FreeIPA from the inventory, using LDIF or the FreeIPA administrative tools, because the migration path does not transfer them. Each rule is tested on a non-production host with an account that should be allowed and one that should be denied. Done means every inventoried rule has a matching test result, and the owner of each rule has accepted the new version in writing.
Move clients and applications
Each client host is enrolled in FreeIPA with SSSD, and each application is repointed from the bare directory's LDAP endpoint to the FreeIPA endpoint, one application group at a time. Applications that bind with simple LDAP credentials need their bind DNs and search bases updated, and any service that needs Kerberos is tested against the new realm. Done means each application has passed a login and read test in the new environment, and rollback steps are documented for that group.
Cut over, run in parallel, then decommission
The team sets a cutover window agreed with the application owners, makes a fresh backup of the source directory and the new FreeIPA servers using FreeIPA's backup tooling, and moves write traffic to FreeIPA. The old directory stays read-only for a period agreed in advance so rollback remains possible. Decommissioning happens only after the owners sign off. Done means no application still reads from the old directory, the final backups are stored with the recovery steps, and the old servers are removed from DNS and monitoring.
Plan the reverse move with the layers left behind
Moving from FreeIPA back to a bare directory is possible for users and groups, but it leaves behind the Kerberos KDC, the Dogtag certificate authority, the DNS and NTP services and the host policy layer. A reverse plan lists which applications depend on those layers, how certificates would be reissued and how Kerberos service principals would be replaced. Done means the team can name each dependency that would need a new owner, and it is recorded in the same inventory used at the start of this sequence.
Where FreeIPA and 389 Directory Server projects run long
The schedule usually slips in the areas that sit outside the directory itself. DNS design is the first. A FreeIPA install ties client resolution, service discovery and, if used, the integrated DNS servers to the IPA domain, and the team has to settle that domain name before anything else is built. If a cross-forest trust with Active Directory is planned, the IPA domain must not overlap any DNS domain in the AD forest, so that check belongs in week one, not at trust setup. Client enrollment is the second source of delay. A mixed fleet of Linux hosts, appliances and systems with local customizations rarely enrolls in one pass, and each exception adds a test cycle. The third is certificate chain decisions made late. Whether the integrated Dogtag CA runs with a self-signed root, is signed by an external CA, or is replaced by certificates from an outside CA changes how services get certificates and how renewal is handled. Revisiting that choice after hosts are enrolled is expensive.
Application LDAP integration is where the bare 389 Directory Server option most often runs long. Each application expects its own bind accounts, group structure and schema attributes, and changes to the schema or access controls (ACIs) are made online through LDAP operations, which makes them easy to make and hard to roll back cleanly. Ask every application owner for a written list of required attributes and a dedicated test account before design starts. Replication and restore testing is the step most often skipped under pressure. FreeIPA's backup documentation warns that restoring an outdated backup into an active replica topology can break replication, so a restore drill against a copy of the topology is the check to schedule, not assume.
The work needs named owners on the client side: directory owners for the schema, groups and replication topology, DNS and PKI owners for the name space and certificate chain, and application owners who can provide test access and sign off on their LDAP behavior. DeployOpen works from a fixed-scope written agreement, so the scope, deliverables and timelines are agreed in writing before work starts, and a quote follows from that scope. Ask each owner group to confirm availability and decisions in that scope document, because the open decisions above are what move dates.
Questions buyers ask before choosing FreeIPA or 389 Directory Server
Is FreeIPA simply 389 Directory Server with extras?
Largely yes at the directory layer, but FreeIPA is more than a packaged LDAP server. FreeIPA uses 389 Directory Server as its multi-master LDAPv3 directory for users, groups, hosts and policies, then adds an MIT Kerberos KDC for single sign-on, the Dogtag certificate authority, SSSD on clients and optional ISC BIND DNS and NTP. The directory is the foundation; the extras are the parts that make it an identity platform for Linux and UNIX estates. Confirm which of these components you need, because each one adds configuration, replicas and patching work that a bare directory does not carry.
Can a team start with the bare directory and add Kerberos later?
Start with the bare directory only if your near-term needs are LDAP reads and writes for applications. Adding Kerberos, certificates and host policy later means building a second identity layer around the directory, not flipping a switch, because FreeIPA's Kerberos realm, CA and DNS are installed and configured as one system. Check how your chosen tooling would reconcile data and schema changes, and test the migration path on a copy of your directory before you commit. Ask the vendor or community maintainers which upgrade paths they support from a directory-only deployment.
How much more operating effort does FreeIPA need?
FreeIPA needs more operating effort because it runs more services. The FreeIPA deployment recommendations advise at least two to three replicas in each datacenter, no more than four replication agreements per replica, at least one replica per datacenter running PKI or DNS if used, and dedicated servers without other applications. A bare 389 Directory Server still needs replication design and backups, but it does not carry Kerberos key management or CA renewal duties. Effort rises with the number of sites, the number of hosts enrolled, and whether you run the CA and DNS. The FreeIPA backup documentation also warns that restoring an outdated backup into an active replica topology can break replication, so budget time for restore drills.
Is a paid support plan needed?
No paid support plan is required to run FreeIPA, because it is a GPL-3.0-or-later community project with no paid edition of its own. 389 Directory Server is also GPLv3 code. Whether you need a paid plan depends on your risk tolerance, your compliance obligations and how many people on your team can debug Kerberos, certificate or replication faults. Red Hat sells a supported build of Identity Management on RHEL, and FreeIPA is packaged in Fedora, Debian, CentOS and RHEL. Ask any provider which versions and distributions they will support, and what response times and escalation paths are included in writing.
What does the work need from our own staff?
Your staff must own the decisions and the operations, even when an outside team builds the system. Expect the work to need people who understand Linux administration, DNS, certificates, Kerberos ticket behavior and LDAP schema, plus someone who owns the on-call and patch cycle. For the bare directory, the skills centre on replication, ACIs and backup. For FreeIPA, add CA lifecycle, Kerberos principals and client enrollment through SSSD. Confirm internally who will approve certificate renewal, who runs the restore drills and who answers for the first server, which handles certificate renewal and CRL publication by default.
Can our own team implement this without an outside partner?
A capable Linux team can implement either option, but the decision depends on the skills and time you can commit. The bare directory can be stood up with dscreate, managed with dsctl, dsconf and dsidm, and watched through the Cockpit console, which is a smaller learning curve. FreeIPA adds the Kerberos realm, Dogtag and DNS, and the deployment choices made at install time are hard to unwind. If your team lacks that depth, a fixed-scope implementation partner can build, document and hand over the system, with scope, deliverables and timelines agreed in writing before work starts. DeployOpen plans, implements, integrates, hardens, backs up and documents self-hosted platforms in the client's own infrastructure, and quotes follow from the written scope.
How hard is it to switch later?
Switching is manageable for user and group data and harder for the parts that bind to Kerberos and certificates. FreeIPA provides migration from other LDAP servers with the ipa migrate-ds command, which excludes Kerberos attributes that FreeIPA regenerates, and sudo and HBAC rules need manual migration through LDIF. In the other direction, 389 Directory Server ships openldap_to_ds, which converts an OpenLDAP server on a best-effort basis. Moving off FreeIPA means re-keying clients, reissuing or re-trusting certificates and rebuilding host policy. Ask each vendor or maintainer to document the export path and the time your environment would need for a rehearsal.
How DeployOpen helps choose, implement or migrate between them
DeployOpen plans, implements and supports self-hosted open-source platforms inside your own infrastructure, so the choice between a bare 389 Directory Server and the full FreeIPA stack is settled against your environment rather than a generic template. We start from the services your Linux estate actually needs, then scope the work in writing before anything is built.
How we scope
- Inventory which applications need LDAP only and which need Kerberos, host policy, sudo or certificates
- Confirm replica count, sites and whether an Active Directory trust is required
- Agree deliverables and timelines in a fixed-scope written statement before work starts
How we build
- Deploy the chosen stack in your own cloud accounts, data centers or air-gapped network
- Configure replication topology, backups with ipa-backup and access controls on the directory
- Test authentication paths, failover between replicas and restore procedures before go-live
How we hand over
- Document the architecture, replication agreements, certificate authority role and backup runbooks
- Deliver configuration records and an operator guide written for your own administrators
- Walk your team through routine tasks such as adding replicas, rotating credentials and restoring data
How we support
- Offer ongoing support, upgrades and continuous testing as a retainer after handover
- Plan upgrades for the directory and Kerberos components against the release notes in use
- Prepare configuration and evidence for compliance assessments, while independent auditors issue any reports

